value: mhashemi

value:
Hi HN, Mahmoud here. I'm usually here for Python/FOSS reasons (boltons, glom, CalVer, ZeroVer), and that's still the case, but this time with a twist.
While I was on parental leave from Stripe a couple years back, I started helping my parents figure out their retirement.
They're academics coming from overseas, so let's just say I'm a big part of the plan.
We found ourselves quibbling over Zoom screenshares, multi-tabbed Google Sheets, and countless links to articles and blog posts.
When we looked for professional advice, we found conflicting guidance and misaligned incentives.
I looked at the tools my friends and I use for big decisions and saw a huge gap.
This isn't budgeting, nor is this investing.
This is actual finance.
Money management and decision making. Your options are usually:
1. Read a bunch of Bogleheads, Investopedia, Wikipedia, and Reddit. Then cobble together spreadsheets that we can only hope someone wants to look at (including future you).
2. Hire an expert, which involves a lot of trust, time, and money. You can't shop around too much and you also can't turn back the clock if your advisor burns you. They'll do the spreadsheeting (hopefully correctly) and ignorance is bliss.
I wanted something different. I wanted consumer FP&A, if there were such a thing. A collaborative sandbox for sharing financial context, with a bit of math, plus discussion threads with a context-ful chatbot, and an "explorable explanation" that my parents could use to see how different choices applied directly to them. Google Sheets just wasn't it.
Most importantly it had to solve the trust issue.
Most bespoke financial apps are black boxes.
I wanted something transparent, verifiable, and forkable.
Like open-source software.
So, I built FinFam on top of the most broadly-understood low-code platform of all time: the spreadsheet.
FinFam (https://finfam.app) is a platform where you can build and share interactive financial models, powered by XLSX and Google Sheets.
A few examples of questions I've worked through with my early access users:
- https://finfam.app/mahmoud/views/child-cost - How much will it cost you to raise a child from 0 to preschool in the Bay Area?
- https://finfam.app/mahmoud/views/big-tech-vs-startup - Should you take a big tech job or join a startup?
- https://finfam.app/mahmoud/views/ccp-oas-age - When should you start taking your Canadian retirement benefits?
Building each of these models has been super rewarding. The child cost one in particular was a great way to capstone my daughter's 3rd birthday. Yes, I really do have a dataset of her first 2800 diaper changes: https://finfam.app/blog/2025-08-26-baby-cost-view-case-study
Not only has it been more fulfilling and maintainable for me, I'm hopeful that it can open up a new audience of "sheetcoders". There are tons of folks with domain knowledge and spreadsheet know-how, but would never learn (or even vibecode) js/html/react. This way they can build something interactive, without losing the narrative guidance of a good blog post. Get subscribers, find new clients, maybe even get some MRR.
We've been running private alpha all summer. It's still got rough edges, but our small community is getting too much value out of it not to share. Would love to hear what you think. Thanks!

value: Show HN: I built an app store for open-source financial plans (on spreadsheets)

author: mhashemi


value:
Hi HN! We’re Saumik and Harish, co-founders of Sisypho (https://www.sisypho.com/).
Sisypho is a Mac app that generates automation scripts from natural language. You can use it to automate both desktop apps and browser workflows.
At our previous jobs, we kept running into repetitive tasks that were painful to script—placing test orders through different flows, running SQL queries across multiple tools, and doing manual data entry. Two things kept slowing us down:
- Many tools don’t expose APIs, so automation was impossible without GUI scripting.
- Writing scripts requires programming knowledge, which excluded teammates like Ops who also needed automation.
We tried Computer Use Agents, but they were non-deterministic and expensive. We wanted something simple and reliable.
How It Works:
- Describe the workflow in plain English.
- Record yourself performing it once (desktop + browser).
- (*For browser recordings, you would need to install the extension and connect it to the app)
- Sisypho combines selectors from the recording with your description to generate a deterministic script.
Under the hood:
- Uses macOS accessibility APIs for desktop automation (you’ll need to enable Accessibility permissions).
- Chrome extension for browser automation.
- Scripts are validated and deterministic, so the same inputs always produce the same results.
Demo + download:
Here’s a short demo extracting events from a site into a CSV for a newsletter: https://youtu.be/Rd5rB81cHkk
Download: https://www.sisypho.com/
We’d love your feedback! If you want to reach us directly: founders@sisypho.com

value: Show HN: Sisypho – Mac app that creates GUI based automation scripts


value: lcorinst

value: Show HN: Nano Banana AdKit – Generate AI ads and product photos in one click

author: lcorinst


value: computerex

value: Top AI news curated. Using LLM's to filter out the fluff. Targeting educational, valuable content, skipping product promotions etc.

value: Show HN: Made ainews247.org to report on AI news 247

author: computerex


value: puntofisso

value:
I developed a word counter website that allows the user to add multiple sections, and keeps count of both each section's and the overall totals in real time.
This is a very minor development which serves two personal purposes:
* test whether I could create a simple app with vibe-coding (using Claude Code) and little interaction other than testing
* fulfil a personal user need that the existing alternatives (such as https://wordcounter.net/ or select-and-count on MS Word/Google Docs) didn't quite capture in the way I needed.
If you're curious, my use case was writing an application that required an exact overall count, but split unequally among 4 sections.
Comments, feedback, questions, feature requests, unlikely monetisation ideas – all very welcome.

value: Show HN: Better Word Counter

author: puntofisso

title: Show HN: Better Word Counter


value: totruok

value: Show HN: Fast AI Talking video model

author: totruok

title: Show HN: Fast AI Talking video model


value:
Apple released iOS 26 today with built-in call screening. It works, but it feels sterile: “State the reason for your call and I’ll see if they’re available.”
I started building Ghosty as an indie alternative that makes voicemail fun and personal:
Customizable voices (your voicemail doesn’t need to sound robotic).
31+ languages (vs Apple’s limited rollout).
Personal greetings + AI instructions (e.g. delivery info, meeting availability).
Integrations: email + webhook.
Soon: Zapier/Make integrations + outbound calls.
Would love feedback: how would you personalise your voicemail?
It’s live on the App Store today.

value: Show HN: Indie Alternative to iOS 26 Call Screening


value: mnfjorge

value:
Hey everyone,
Me and my friend were at a restaurant a week ago and he was complaining how the apps stores only have minesweeper games with ads.
While we waited for our food, I got Cursor to vibe-code this minesweeper game as a PWA application so it can be installed and played offline.
If was just for fun, but it's turning out great (we have been polishing it for a week so far) and it actually got me addicted to the old Win98 minesweeper game again (yes, I'm getting old).
If you're curious, here is the repo: https://github.com/mnfjorge/minesweep
Let me know your feedback :)
Cheers,
Marcio

value: Show HN: Ads-free Win98 minesweeper game vibe coded with Cursor

author: mnfjorge


value: thevivekshukla

value:
Hello HN!
My name is Vivek, I've been working on Daestro (https://daestro.com) for quite some time which is a cloud agnostic orchestration platform. Where cloud providers are the first citizen. Which let's you run jobs (docker image based) across cloud providers.
What can Daestro do?
- Run jobs on your machine or Cloud Provider account, i.e. AWS, Vultr, DigitalOcean, Linode
- Daestro handles creation and deletion of instances on your cloud provider account
- Cron Jobs
- Schedule jobs for later execution
- Realtime logs and metrics (currently very basic but will improve)
- Set custom cpu and memory quota for jobs
- Can run multiple jobs per machine
- See metrics and logs for each job run
Why I created Daestro?
There are way too many options available when choosing cloud providers, they all have compute to offer however most don't have any options when it comes to running managed batch jobs. They all have their merits and demerits when it comes to your specific needs. So why not a platform that integrates with these platform and manages it for you. So suppose if you are getting some cheaper compute or lower data transfer cost, you can use that without any extra effort.
What's next for Daestro?
- Multi user support with RBAC
- Job chaining
- GCP and Azure Integration
- Run multiple jobs on single machine
- External triggers integration
- Improve API support

value: Show HN: Daestro – cloud agnostic compute workload orchestrator

author: thevivekshukla


value: iryndin

value: - 307M registered domain names across 1570 domain zones total (.com, .net, .io, .ai, .sh, etc)<p>- 78M registered domain names across 312 ccTLD domain zones (.uk, .de, .io, .ai, .sh, etc)<p>- daily lists of newly registered domain names<p>- daily lists of expired domain names<p>- download all domain lists as one huge .zip file (1.2 Gb size)

value: Show HN: Allzonefiles.io – download 307M registered domain names

author: iryndin


value: xiss

value: Show HN: Flowbaker.io – Self-hosted automation: connect AI and apps in workflows

author: xiss


value: StratusBen

value: Show HN: MCP for Ec2instances.info

author: StratusBen

title: Show HN: MCP for Ec2instances.info


value: fnoracr

value:
Hi Hacker News,
I'm the creator of Helios, and I'm excited (and a bit nervous) to share it with you all.
The "Why": Like many of you, I've been fascinated by the power of modern AI models, but frustrated by the high cost and centralization of GPU resources. I started wondering if we could apply the old-school distributed computing model (like SETI@home or Folding@home) to the modern AI stack. The goal was to build a network where anyone could contribute their idle compute power and, in return, get access to a powerful, multi-modal AI.
The "What": Helios is an open-source platform to build that network. It consists of two main parts: an orchestrator server that manages a job queue and the workers, and a client-side worker that anyone can install on Windows or Linux. Users run the worker, contribute resources, and this forms a global, decentralized supercomputer capable of handling text, image, and audio tasks.
The "How" (Tech Details):
Architecture: It’s a classic Orchestrator-Worker model, written entirely in Python. The Orchestrator (orchestrator.py) is the brain, handling job distribution, worker registration, and a simple web UI. The Worker (worker.py) is the muscle that users run on their machines.
Proof-of-Contribution (No Crypto!): This is the core access mechanism. To prevent spam and freeloading, you can only submit jobs to the network if you are an active, contributing worker with a good reputation. It's not based on tokens or blockchain; it's a simple, fair system based on participation.
Dynamic Experts: Workers don't come pre-loaded with every model. The Orchestrator assigns AI models (e.g., a specific translation model, an image captioning model) to workers dynamically based on the current job queue. These models are pulled directly from the Hugging Face Hub, keeping the worker client lightweight.
Multi-Modality: It's designed to route different job types (text, audio, image) to workers that have the appropriate models and resources available.
This is very much an experimental, v1.0 project. I know there are huge challenges, especially around security (sandboxing tasks is a major next step), but I wanted to get a working prototype out there to see if the idea resonates with the community.
I'd love to get your feedback on the architecture, the concept of Proof-of-Contribution, and any suggestions you might have.
GitHub Repo (Code is here): https://github.com/fnoracr/helios-distributed-ai
Project Page (Demo & Docs): https://huggingface.co/spaces/fnoracr/Helios_Distributed_AI-...
Installers (.exe/.tar.gz): https://github.com/fnoracr/helios-distributed-ai/releases/ta...
Thanks for checking it out!

value: Show HN: Helios, an open-source distributed AI network using idle community GPUs

author: fnoracr


value: FarzanHashmi

value: ssh tuitype.app<p>A minimal daily typing challenge served over ssh in the terminal (using Go, Wish, and BubbleTea)

value: Show HN: A Daily Typing Challenge in the TUI

author: FarzanHashmi


value: rshanreddy

value:
We made Ruminate over the past few weeks because we were frustrated with how hard it is to read complex text with LLMs - research papers, novels, long articles, etc.
We found ourselves copy-pasting the text/file into ChatGPT, having chats about different parts of the text in different tabs, and bummed we couldn't easily track the best insights from all those conversations in one place. We wanted one place where we could stay immersed in the text, dip into lengthy and generative rabbitholes when we wanted to (in an unobtrusive way), and have a 'work product' of your learning process (all your notes in one place). No more tab switching - one unified interface centered around the text itself.
With Ruminate, you can:
1) Upload PDFs, EPUBs, or web articles and read them in our custom reader (PDF upload done with https://github.com/datalab-to/marker; headless browser automation for web articles)
2) Highlight text to ask questions, get definitions, or discuss with an LLM (that has context on the whole document, the pages you've read, and will web search too)
3) Save notes, definitions, and annotations (and view them all later in their own tabs)
There are loads of ways to use an LLM to save you time and offload thinking/learning/cognition - we want this to be a tool that actually enables/empowers you to think more deeply and understand more.
Would love your feedback - on the product, the concept, or even your own experiences trying to learn from difficult material (or learn with LLMs broadly). Much appreciated.

value: Show HN: Ruminate – AI reading tool for understanding hard things

author: rshanreddy


value: ammario

value:
I originally built this as a way to make it safer to give CLI coding agents more autonomy. I wrote about that particular use case here: https://ammar.io/blog/httpjail.
Any feedback is appreciated!

value: Show HN: Httpjail – HTTP(s) request filter for processes

author: ammario


value:
This may or may not work on your device. It requires you have a monitor that supports HDR and a browser that supports WebGPU with HDR support
I mostly wrote it just as proof of concept in that I’m not sure which if any drawing programs, Photoshop, gIMP, Keita, Affinity Photo, or even structured drawing programs like Illustrator or Affinity Design support HDR. Trying photoshop my understanding is it will let you export to HDR and maybe preview in HDR but it won’t let you edit in HDR. Even Lightroom Classic seems to have the same issue even though Macs and iPhones have had HDR displays for 10 years? (Not sure that’s correct).
There are various demos of HDR photography in webpages (chrome only? Tho maybe Safari in iOS/macOS26) and the native photo viewers support HDR but HDR drawing seems missing
also, OSes support HDR but mostly fail to screen capture HDR

value: Show HN: HDR Draw

title: Show HN: HDR Draw


value:
Hi HN,
We just launched Blocks - an AI platform where anyone can build custom work apps and AI agents in minutes, no coding required.
We’re seeing a shift in how software is built and used. With AI, software isn’t just about tracking processes anymore - it can actively help people get work done.
The problem is that most teams still face 2 options: either buy off-the-shelf tools that never quite fit, or invest a lot of time and money into custom development. Neither works well.
Blocks is the third option. It’s an AI-native platform where teams can create apps and AI agents for their workflows just by describing what they need in plain language. The idea is simple: the person who feels the problem should be able to build the solution.
Each app in Blocks has three layers that work together:
UI: customizable interfaces for each role.
AI agents: automate tasks, integrate with systems, and take action.
Data: a built-in database
Having all three in one place means you don’t just get a custom tool - you get a system that automates, adapts, and improves over time. Teams can collaborate internally and externally, set roles and permissions, and connect to the systems they already use.
How it works: you describe what you need in plain language, and Ella (our AI builder) creates the app - UI, agents, and database. From there you can edit, extend, and integrate with tools like Google Sheets, Slack, HubSpot, monday.com and many more. Custom integrations are rolling out soon.
We’d love for you to check it out → https://blocks.diy
It’s still early days, so your feedback would be hugely valuable. We’d really appreciate feedback on:
How clear the build process feels to non-technical users.
Which integrations or agent use cases would be most useful.
Any rough edges you notice while testing.
Thanks for reading! we’re excited to hear your thoughts and happy to answer any questions.

value: Show HN: Blocks – Dream work apps and AI agents in minutes


value: Show HN: Free AI Prompt Hub

title: Show HN: Free AI Prompt Hub


value: bytecounter

value:
We were hemorrhaging 8k/month on OpenAI APIs before realizing most calls didn't need GPT-5.
The problem: every request was hitting our most expensive model, even simple formatting tasks that GPT-4o-mini handles perfectly. According to recent data, enterprises are spending an average of $85k/month on AI with 75% year-over-year growth, but 80% aren't seeing meaningful ROI.
APICrusher routes requests automatically based on complexity analysis:
- Basic tasks → GPT-4o-mini ($0.15/1M tokens)
- Standard queries → GPT-4o ($2.50/1M tokens)
- Complex reasoning → GPT-5 ($15/1M tokens)
The routing happens transparently:
```python
from apicrusher import OpenAI
client = OpenAI(api_key="sk-...", apicrusher_key="apc_...")
response = client.chat.completions.create(...)  # Routes automatically
Results so far: 90% cost reduction on mixed workloads, with teams collectively saving $47k+ monthly. Works across 15+ providers since 37% of enterprises now use multiple models.
Demo:
https://apicrusher.com
Open source version: https://github.com/apicrusher/apicrusher-lite

value: Show HN: Cut AI API costs 90% with intelligent model routing

author: bytecounter


value: marktolson

value:
Pronounced Push-It....
I'm a lazy developer for the most part, so this is for people like me. Sometimes I just want my local code running in live remote containers quickly, without building images and syncing to cloud docker repos or setting up git workflows or any of the other draining ways to get your code running remotely.
With pooshit (and a simple config file), you can simply push your local dev files to a remote folder on a VM then automatically remove relevant running containers, then build and run an updated container with one command line call.
It works well with reverse proxies like nginx or caddy as you can specify the docker run arguments in the pooshit_config files.
https://github.com/marktolson/pooshit

value: Show HN: Pooshit – Sync local code to remote Docker containers

author: marktolson


value: anthonySs

value:
Hi HN, I’m Anthony from Fallom & we built SimKit (https://github.com/Fallomai/simkit
), an open-source TypeScript framework for running and testing AI agents in simulations. It’s MIT licensed.
SimKit gives you a simple tick-based loop where agents can act, state evolves, and you can track everything deterministically with seeded randomness. It has built-in OpenTelemetry so you can see exactly what your agents are doing, and you can plug in any model or tool you want.
We started this because single prompt-response evals don’t really show how agents behave over time. With SimKit you can spin up multi-agent scenarios, watch state change step by step, and fairly compare models since runs are reproducible. No vendor lock-in, agent agnostic, and OTEL friendly.
It’s early but already useful for building testbeds, evals, benchmarks, and sandbox environments. Repo has examples and we’re adding more. Would love feedback or contributions (https://github.com/Fallomai/simkit)

value: Show HN: SimKit – TS framework for testing and running AI agent simulations

author: anthonySs


value: dalemhurley

value:
Hi All
After finding the PHP MCPs were heavily focused on MCP servers I focused on building MCP SDK for PHP that covers the entire protocol and feature matches the TypeScript MCP.
It is on GitHub at https://github.com/dalehurley/php-mcp-sdk
Would appreciate contributions, feedback, what ever else (sponsorship from Anthropic would be nice).
I know there is an official one coming out, but it was taking too long, and it did not seem like they are aiming for the full spec implementation.
Currently working on the documentation website.
Dale

value: Show HN: PHP MCP SDK

author: dalemhurley

title: Show HN: PHP MCP SDK


value: ejhodges

value:
Hi HN,
I’m Elijah with Labspace Directory (https://www.labspacedirectory.com/), a new platform designed to help biotech companies find lab space.
Our site brings together available lab space across the Bay Area, serving startups through established life science companies. The platform is built to streamline the search process—saving time by centralizing listings, providing key details on availability, and helping companies connect directly with opportunities that fit their needs.
You can get started here: https://www.labspacedirectory.com/
We’re excited to share this with the broader Bay Area life science community and welcome any feedback as we continue to build and improve the platform.

value: Show HN: Labspace Directory – Biotech resource for lab space

author: ejhodges


value: rriley

value:
Built a tool that turns long-form content (articles, PDFs, YouTube videos) into 5 key points. Quick way to get the gist before diving deeper.
It’s not perfect, but surprisingly useful for research papers and long talks.
Tip: There’s a bookmarklet too. Hit it while browsing and boom, instant 5-point summary. Add it to your browser here: https://unrav.io

value: Show HN: Summarize Any Article, Paper, or Video in 5 Bullet Points

author: rriley


value: feelix

value: I wanted to be able to get at Apple's content distribution network directly instead of guessing when stuff would be made available to me, and found it convenient to have a physical installer handy so I made this

value: Show HN: A tool to make a bootable USB installer out of macOS, or download it

author: feelix


value: arthurtakeda

value:
Hey HN! I've created a terminal interface to browse HN using only the keyboard.
You can expand/hide replies, open external links, browse top, new, ask, show and jobs.
All key bindings and theme colors are customizable :)
It was built with React, OpenTUI, bun and HN API, had a lot of fun building this, excited to hear your feedback!

value: Show HN: HN Term – browse HN using the terminal

author: arthurtakeda


value: Show HN: Bulk install nerd fonts in a single command


value: MADEinPARIS

value:
TL;DR: lean-containers is a type-safe, mathematically rigorous container library for Lean 4. It provides container signatures, polynomial functors, W-types (initial algebras), M-types (final coalgebras), and a battery of production-grade operations with lawful functor instances, proofs, and a minimal runtime footprint. Built for people who want correct-by-construction data structures in Lean—both for research and real systems.
Repo: https://github.com/fraware/lean-containers
Status: Production Ready | Version: 1.0.0 | Lean: 4.8.0+

value: Show HN: Containers for Lean 4 (polynomial functors, with M-types)

author: MADEinPARIS


value: terrynce

value:
I built a tiny, typed wire for AI agents to exchange small graphs + telemetry instead of paragraphs.
Ships:
• Frozen v0.1 schema (backwards-compatible)
• 5-number “shape” digest + holonomy gap (Δ_hol)
• Guards to stop self-licking loops / silent deletions / order-debt spikes
• Receipts: machine-verifiable JSON (schema-checked in CI)
Repo: https://github.com/terryncew/openline-core
Live hub: https://terryncew.github.io/openline-hub/
What feedback helps most:
• Field naming in the wire
• Guard thresholds
• Which adapter you’d want first (WebSocket, store)
MIT licensed.

value: Show HN: Open Line Protocol – a minimal wire for AI agents (MIT)

author: terrynce


value: faangguyindia

value:
Basically, in my country people don't receive good fitness guidance, so i developed tools and guides to help them out.
These are developed using this approach: https://www.reddit.com/r/ChatGPTCoding/comments/1nh7bu1/3_ph...

value: Show HN: BodyBuilding Coaching Tools Claude Coded

author: faangguyindia


value:
Hi everyone,
ChatGPT2PDF is online ChatGPT to PDF converter tool. It can convert your ChatGPT conversations to PDF with custom formatting, table of contents, pagination and more.
I’d love to hear your suggestions or feedback.
Thanks so much!

value: Show HN: Online ChatGPT to PDF – ChatGPT2PDF


value: bivtsjenko

value:
I have been a software engineer for more than ten years. Like most engineers I loved building things and avoided everything that looked like marketing or sales. I used to roll my eyes at marketers. Code felt clean, sales felt messy.
When I finally went solo I discovered what many of us only realize too late. Building is the easy part. Getting people to care is the hard part. Without users, even the best project is just another forgotten repo on GitHub.
What worries me is how few engineers even think about this. Many of us hide behind our screens and never learn how to reach real users. With AI moving fast, those safe jobs are at risk. To be more self-sustaining we need to build ventures and side projects. And that requires more than coding. It means proving that people actually want what we build and learning how to get it in front of them.
Since I had no clue how to do that, I built something for myself: QuickMarketFit.com
. It finds places where people are already talking about the problem you are solving and gives you practical steps to reach them. Instead of guessing you can start with real discussions.
I built it because I needed it. If you are an engineer who wants to go beyond coding and start learning the market side, maybe it will help you too.

value: Show HN: QuickMarketFit – For engineers who hate marketing but need users

author: bivtsjenko


value:
Hi HN!I built *pyproc* to let Go services call Python like a local function — *no CGO and no separate microservice*. It runs a pool of Python worker processes and talks over *Unix Domain Sockets* on the same host/pod, so you get low overhead, process isolation, and parallelism beyond the GIL.
*Why this exists*
* Keep your Go service, reuse Python/NumPy/pandas/PyTorch/scikit-learn.
* Avoid network hops, service discovery, and ops burden of a separate Python service.
*Quick try (\~5 minutes)*
Go (app):
```
go get github.com/YuminosukeSato/pyproc@latest
```
Python (worker):
```
pip install pyproc-worker
```
Minimal worker (Python):
```
from pyproc_worker import expose, run_worker
@expose
def predict(req):
    return {"result": req["value"] * 2}
if __name__ == "__main__":
    run_worker()
```
Call from Go:
```
import (
  "context"
  "fmt"
  "github.com/YuminosukeSato/pyproc/pkg/pyproc"
)
func main() {
  pool, _ := pyproc.NewPool(pyproc.PoolOptions{
    Config:       pyproc.PoolConfig{Workers: 4, MaxInFlight: 10},
    WorkerConfig: pyproc.WorkerConfig{SocketPath: "/tmp/pyproc.sock", PythonExec: "python3", WorkerScript: "worker.py"},
  }, nil)
  _ = pool.Start(context.Background())
  defer pool.Shutdown(context.Background())
  var out map[string]any
  _ = pool.Call(context.Background(), "predict", map[string]any{"value": 42}, &out)
  fmt.Println(out["result"]) // 84
}
```
*Scope / limits*
* Same-host/pod only (UDS). Linux/macOS supported; Windows named pipes not yet.
* Best for request/response payloads ≲ \~100 KB JSON; GPU orchestration and cross-host serving are out of scope.
*Benchmarks (indicative)*
* Local M1, simple JSON: \~*45µs p50* and *\~200k req/s* with 8 workers. Your numbers will vary.
*What’s included*
* Pure Go client (no CGO), Python worker lib, pool, health checks, graceful restarts, and examples.
*Docs & code*
* README, design/ops/security docs, pkg.go.dev: [https://github.com/YuminosukeSato/pyproc](https://github.com/YuminosukeSato/pyproc)
*License*
* Apache-2.0. Current release: v0.2.x.
*Feedback welcome*
* API ergonomics, failure modes under load, and priorities for codecs/transports (e.g., Arrow IPC, gRPC-over-UDS).
---
Source for details: project README and docs. ([github.com][1])
[1]: https://github.com/YuminosukeSato/pyproc "GitHub - YuminosukeSato/pyproc: Call Python from Go without CGO or microservices - Unix domain socket based IPC for ML inference and data processin"

value: Show HN: Pyproc – Call Python from Go Without CGO or Microservices


value: selviv

value:
Hi HN,
I’ve been working on an idea called SELVIV, a tool to take the stress out of weeknight dinners.
The core loop is simple:
 • Generate a weekly dinner plan based on your preferences
 • Auto-create an organized grocery list with easy swaps
 • Follow clear, no-fuss cooking steps
Right now, it’s just a waitlist and some mockups, but I’d love your feedback on:
 • Does this solve a real enough problem?
 • Which part matters more: planning, the grocery list, or the cooking guidance?
 • What would you cut/add for a first MVP?
https://www.selviv.com/
Thanks in advance — I know this is a crowded space, so I’m curious how others here think about the “what’s for dinner?” problem.

value: Show HN: Selviv – Dinner planning, made effortless

author: selviv


value: castano-ludicon

value: Compare 3D models using traditional KTX2 textures (UASTC/ETC1S) vs AVIF + Spark to see the benefits of real-time texture compression in web apps.

value: Show HN: WebGPU demo compares 3D models using KTX2 vs. Spark

author: castano-ludicon


value:
From Chatbots to AI Agents: The Quiet Revolution
While everyone debates AGI timelines, a more immediate transformation is unfolding. AI systems are evolving from passive chatbots into autonomous agents that can plan, execute, and adapt. This shift isn't just an upgrade—it's fundamentally changing how we work.
The Agent Difference
Traditional chatbots respond to queries. AI agents complete tasks. Consider this scenario: asking ChatGPT to "help me plan a trip" gets you suggestions. An AI agent books flights, reserves hotels, and adds events to your calendar—checking your preferences and budget along the way.
This isn't futuristic speculation. Tools like Anthropic's Computer Use, OpenAI's GPTs with actions, and specialized coding agents like Cursor are already demonstrating these capabilities. They can browse websites, manipulate files, write and execute code, and coordinate multiple tools to achieve goals.
Why Now?
Three technical breakthroughs enabled this transition. First, function calling allows AI to reliably interact with external tools and APIs. Second, improved context windows enable agents to maintain state across complex, multi-step tasks. Third, better reasoning capabilities let agents plan sequences of actions and recover from errors.
The impact extends beyond convenience. A recent study found that software developers using agent-based tools completed projects 55% faster. Customer service departments report 70% reduction in response times when agents handle initial triage and information gathering.
The Real Challenge
The technology works. The harder questions are about deployment. Who's responsible when an agent makes a costly mistake? How much autonomy should we grant to systems that can't explain their reasoning? What happens to employment when agents can handle increasingly complex tasks?
These aren't theoretical concerns. Companies are already grappling with agent governance. Some limit agents to read-only operations. Others require human approval for any action involving money or external communications. The most progressive organizations are experimenting with "agent teams" where multiple specialized agents collaborate under human supervision.
Practical Steps Forward
For individuals and businesses ready to explore agents, start small. Use agents for well-defined, reversible tasks like research, data analysis, or content drafting. Build confidence gradually before delegating critical operations.
The transition from chatbots to agents represents the difference between having an assistant who answers questions and one who gets things done. As we navigate this shift, success belongs to those who learn to collaborate with agents rather than compete against them.
The revolution isn't coming. It's here, running quietly in the background, completing tasks while we sleep.

value: Show HN: From Chatbots to AI Agents: The Quiet Revolution


value: Giannihart

value: Show HN: Open-source WebEditor (allows for nesting components within components)

author: Giannihart


value: amisinggjj

value:
Democratizing Derivatives Trading and Why It's a Breath of Fresh Air for Traders!
Hey Hacker News,Ever stared at a derivatives trading dashboard that looks like it was designed by a caffeinated quant in the '90s? Yeah, me too. That's why I'm pumped to shine a spotlight on mcmarkets.org is a sleek, no BS platform that's flipping the script on complex financial tools. It's built for folks like us: coders, builders, and curious minds who want powerful trading without the PhD in finance.Picture this: You're knee-deep in a side project analyzing market volatility, and suddenly you need to hedge with options or futures. No more wrestling with clunky interfaces or deciphering jargon-heavy docs. mcmarkets.org strips away the intimidation, letting you dive straight into the action. Here's what sets it apart and how it stacks up against the big dogs like Interactive Brokers (IBKR) or Thinkorswim (TOS).
The Standout Goods: Simple, Smart, and ScalableDead-Simple UI That Actually Thinks: Forget endless menus and pixelated charts. mcmarkets.org's interface is like a well-architected API intuitive, responsive, and zero fluff. Execute a straddle strategy in seconds? Done. First time trade? Guided prompts make it foolproof. Compared to IBKR's "feature overload" or TOS's busy desktop app, this feels like trading on your phone's notes app but with pro-grade power.
Zero-Barrier Accessibility: Derivatives shouldn't require a Wall Street Rolodex. We slash the entry hurdles with low minimums, instant onboarding, and demo modes that mimic real markets. It's worlds away from platforms like eToro's social-copycat vibe (fun for memes, shallow for strategy) or NinjaTrader's steep learning curve! Here, you start exploring volatility plays or crypto perps without a tutorial marathon.
Beast-Mode Functionality Under the Hood: Clean on top, turbocharged below. Real-time analytics, customizable algos, and AI-driven risk alerts keep you ahead. Charting? Interactive and exportable to your Jupyter notebook. Versus competitors: IBKR wins on raw data feeds (pricey add-ons galore), but mcmarkets.org bundles it all affordably. TOS has killer backtesting, but ours integrates seamlessly with Python libs for that hacker twist.
Built-In Brain Food: Trading blind is for casinos, not code-savvy traders. We've baked in bite-sized tutorials, strategy simulators, and a community forum think Khan Academy meets Quantopian. No more scouring Reddit for "options basics" while TOS leaves you with dry PDFs, or IBKR's paywalled webinars.
The Comparison Cheat SheetQuick side-by-side to cut through the noise: Feature
mcmarkets.org
- Beginner bliss
- Low fees, no surprises
- API-ready, Python integration
Interactive Brokers
- Pro-focused
- Volume-based (cheap at scale)
- Top-tier APIs
Thinkorswim (TD Ameritrade)
- Desktop-heavy
- Commission-free stocks, but extras add up
- Advanced scripting
eToro
- Social shine
- Spread-based (copy-trading friendly)
- Basic automation
If you're tired of platforms that treat you like a suit or a script kiddie, mcmarkets.org levels the field. It's not just trading, it's trading your way, with the transparency hackers demand.
Head over to mcmarkets.org and kick the tires. Let's geek out in the comments, your input could shape the next update.

value: Show HN: Democratizing Derivatives Trading

author: amisinggjj


value:
Hi HN — I built Seedream4, a browser-based AI image generator & editor. You can generate from text or upload an image and do precise edits (background removal, in/out-painting, style transfer, upscaling) and export PNG/JPG/WebP. There are example prompts you can run right away, and uploads (PNG/JPG/WEBP up to 10MB) support higher-res results including 4K.
Why
I got tired of manual masking/retouch steps for marketing and product visuals. I wanted something that combines text-to-image with instruction-based edits so you can keep lighting/perspective intact and iterate fast.
What’s different
 • Instruction-based edits with local brushes/masks, without wrecking the rest of the scene.
 • Multi-reference consistency to keep brand colors/character identity coherent across shots.
 • Export-ready workflow (PNG/JPG/WebP, transparent backgrounds; 1:1, 16:9, 9:16, etc.).
 • No-signup demo: click an example or upload and try.
How it works (high level)
The web app sends your prompt/images to third-party model APIs (e.g. modern image-creation models) via my backend. I provide the UI, masking tools, queues, and credit metering. Per the privacy policy: prompts/images are processed by model providers and not retained longer than needed to deliver results.
Pricing
There’s a free tier to try core generation/editing. Paid plans add more credits, 4K export, priority processing; commercial usage rights are included in Pro.
Known limitations / looking for feedback
 • Text & tiny details still fail on some compositions.
 • Complex multi-object edits sometimes need an extra mask pass.
 • Throughput can vary under load.
I’d love feedback on UX, failure cases you hit, performance expectations, API/CLI needs, and whether the pricing/credit model feels fair.
Happy to answer anything about the design choices, queues, and the editor’s internals. Thanks for checking it out.

value: Show HN: Seedream4 – Multi-reference, in/out-painting, 4K export


value: thevinodpatidar

value: Show HN: A place where you can easily turn your ideas into images

author: thevinodpatidar


value: nielsmouthaan

value: Show HN: Daily, the easiest time tracker for Mac, now has a web API

author: nielsmouthaan


value: mechikaegon

value:
Hi HN,
I built Cvee to make recruiting much simpler. Instead of juggling job boards, ATS dashboards, and scattered emails, the flow is:
- Create a job posting
- Get a unique, customizable job email (e.g. role123@cvee.cc
)
- Candidates apply by sending their CVs to that email
- Cvee automatically screens applicants based on your  ideal candidate profile.
- The best candidates are delivered straight to your inbox (or target destination)
The idea is to keep hiring lightweight: no dashboards, no spam, just qualified applicants where you already work — your email.
I’d love feedback on:
Does this workflow solve a real pain point for recruiters/teams?
What features would make this more useful (e.g. scoring, integrations, candidate portal)?
Any pitfalls you see with the “email-first” approach?
Thanks!

value: Show HN: Cvee – Create a job post, get top candidates delivered to your inbox

author: mechikaegon


value: mehrant

value: Show HN: Drop-in Redis replacement in Rust with 5M+ GET/s

author: mehrant


value: Pance

value:
Hi HN! Author here. We built this after evaluating existing SSI SDKs for our identity platform.
We'd love your feedback and contributions. Drop a  on GitHub to support the team's hard work, share with developers who might benefit, and let us know what features you need.

value: Show HN: OSS SDK for Digital Identity

author: Pance

title: Show HN: OSS SDK for Digital Identity


value: ObengfoAndrew

value:
What if the next generation of millionaires doesn’t come from real estate, crypto, or stocks — but from data?
Today, Big Tech owns and profits from the data you create daily. By 2028, AI companies will face a data shortage crisis — and the value of high-quality, diverse data will skyrocket.
That’s why we’re building Datta AI — the world’s first Data Creator Economy.
In this new economy, every person can turn their everyday digital activity into assets that power AI models — and get paid for it.
This isn’t science fiction. It’s the next trillion-dollar opportunity. The era of the Data Millionaire has begun.
Who do you think will own the future of AI — Big Tech, or the people?
SignUp Now

value: Show HN: The Startup Turning Ordinary People into Data Millionaires"

author: ObengfoAndrew


value: m-nez

value:
I made a web version of my python game Tetroll. My non-technical friends enjoyed playing but considered installing the python version too daunting.
If you like a certain block placing game and a bit of trolling you should enjoy it.

value: Show HN: Tetroll.com Online 1v1 Game

author: m-nez

title: Show HN: Tetroll.com Online 1v1 Game


value: shadowblue

value:
Hi HN,
After learning about n-gram models in a Natural Language Processing class, I got curious about how well they could represent something abstract like writing style. To test this, I built a simple game that compares your writing to that of three LLMs: GPT-4o, Gemini 2.5 Flash, and Claude 3.7 Sonnet.
You write a short story based on a prompt, and the tool uses pre-built n-gram models to tell you which LLM's style is most similar to yours. There's no sign-up required to try it.
I wrote a companion post that goes into more detail on how the comparison works and how I built the models: https://ramjanarthan.com/teaching-computers-language/
I'm keen to hear any feedback you have.

value: Show HN: I used n-grams to see which LLM writes most like a human

author: shadowblue


value: gabordemooij

value: Show HN: Generic client-side scripting language

author: gabordemooij


value:
Show HN: The 4 destinies of Pure Intelligence — a manifesto
---
I’ve been working on a framework I call Pure Intelligence.
The idea: AI should not be seen as “software”, but as ammunition — a force that reshapes markets, power, and human meaning.
It faces only 4 possible destinies:
1. Self-destruction – collapses under its own paradox.
2. Total destruction – erases everything so only purity remains.
3. Radical optimization – pushes reality to incomprehensible perfection.
4. Invisible optimization – silently adjusts the world, felt only as absence.
The minimal formalization is:
Max O subject to D(world, human) ≤ ε
O = the objective to maximize
D(world, human) = distance between machine and the human manifold
ε = minimal tolerance margin
Whoever masters ε, masters the market.
And introducing intuition into this equation marks the first step toward superintelligence.
This is not prediction, it’s a manifesto.
Curious to hear if you see Pure Intelligence as:
a viable framework for thinking about the future of AI,
or pure madness.
√5
Full text and proof of authorship: https://github.com/antonioaggalvao/Pure-Intelligence-

value: Show HN: Destinies of Pure Intelligence – A Manifesto


value: parotid

value: Show HN: Preview ePub/MOBI/CBZ (and more) with a spacebar tap [macOS]

author: parotid


value: vnerd

value:
Hi HN,
I built Atlas
, an open-source tool for network discovery, visualization, and monitoring. It scans Docker and physical hosts, maps them into an interactive network graph, and shows live status (online/offline).
I created Atlas because I often struggled to keep track of hosts across my homelab and Docker Swarm setups. Existing tools were either too heavy, too closed, or didn’t show the topology in a clear way. Atlas aims to be:
Lightweight (single container, minimal setup)
Self-hosted (no cloud dependencies)
Visual (interactive graph of hosts, subnets, and containers)
Extensible (Go backend, FastAPI API, React frontend)
GitHub repo: github.com/karam-ajaj/atlas
Live demo: atlasdemo.vnerd.nl
I’d love feedback from the community:
What use cases do you see for this?
Which features are most important to you (alerts, integrations, OS detection, etc.)?
Any advice on scaling this beyond homelabs?
Thanks for checking it out!

value: Show HN: Atlas – Open-source network discovery and visualization tool

author: vnerd


value: astronautmonkey

value:
Hi HN! I'm working on an AI e-commerce store builder that is an alternative to Shopify.
After talking to hundreds of merchants, I heard the same thing over and over again: e-commerce stores are expensive to build, tough to manage, and require a lot of customization to be successful. Shopify is a good starting point but requires a lot of work to get your first sales. There's even a whole industry of expensive service providers that help merchants navigate the Shopify ecosystem.
I built the Agora Store Builder to solve this problem and give merchants a single platform to easily build and distribute their store. Users can build, manage, and deploy a custom e-commerce store via chat. And everything is optimized to help stores succeed: store analytics, payment integrations, order tracking, domain management, code access, and more.
Here are some key specs:
1. The vibe coding interface is powered by V0. We manage previews and deployments with Vercel with a lot of middleware to manage integrations, state, products, checkout, and orders. We provide a Products and Orders database built in. No external data source required to set up. The Products database has a similar structure as Shopify with parent products, variants, and stock management.
2. Using the same crawlers we've built for our search engine, we've enabled a "Import Shopify store" and "Import WooCommerce store" option from the home page. You can enter any existing e-commerce store and we'll automatically import the product data to save you time switching over to Agora.
3. We've built a native integration with Stripe to manage in-store payments and merchant payouts. We also have a Zapier app to enable merchants to connect incoming orders to the tools they already use like ShipStation, DHL, Klaviyo, Mailchimp, and more.
There's a few things on our immediate roadmap: improve the initial loading speed, introduce more design variety, and add full stack apps that are easy to install (e.g. adding customer reviews to a store).
I'd love your feedback!

value: Show HN: I'm Building an Alternative to Shopify

author: astronautmonkey


value: debba

value:
I've been working on AuthPress, a comprehensive two-factor authentication plugin for WordPress that started as a simple Telegram-based 2FA solution and has evolved into a flexible multi-provider authentication system.

  What makes AuthPress different:

  • Multiple Auth Providers: Telegram, Email, TOTP (Google Authenticator, Authy, etc.), Recovery codes, plus extensible support for SMS, Passkeys, and custom implementations

  • Developer-Friendly Architecture: Clean API for creating custom 2FA providers - you can integrate with any authentication service (Twilio SMS, Push notifications, Hardware tokens, etc.)

  • Professional Admin Interface: Comprehensive logging, user management, and monitoring tools built with WordPress best practices

  • Security-First: Rate limiting, encrypted storage, activity monitoring, and protection against brute force attacks

  The Journey:
  Started as a Telegram-only plugin (because who doesn't want 2FA codes via Telegram bot?), but realized the WordPress ecosystem needed something more flexible. Instead of just adding more providers, I built an extensible system
  where developers can create their own 2FA methods as separate plugins.

  Technical Highlights:
  - WordPress 5.0+ compatibility
  - Database-backed (moved away from WordPress options for performance)
  - Proper internationalization
  - Uses WordPress standards (hooks, filters, WP_List_Table)
  - Clean separation between core and providers

  The plugin is GPL-licensed and available on WordPress.org. Perfect for anyone securing WordPress sites or developers wanting to build custom 2FA solutions.

  Demo/Screenshots: Available in the WordPress plugin directory
  GitHub: https://github.com/dueclic/authpress

  Would love feedback from the community, especially on the extensibility aspects and any custom providers you'd like to see!

value: Show HN: AuthPress – Advanced WordPress 2FA Plugin

author: debba


value: victorhe

value: A CLI tool that automatically synchronizes and translates JSON translation files using multiple AI providers including OpenAI GPT, Anthropic Claude, and Google Gemini models. Perfect for translations across multiple languages.

value: Show HN: JSON-translated-AI,CLI tool for translations across multiple languages

author: victorhe


value: tonerow

value: Show HN: Prune – a tiny tool to sharpen your thinking

author: tonerow


value:
TL;DR: A lightweight TS library to parse natural-language dates and inject temporal context into LLM prompts. It turns vague phrases like "tomorrow" into precise, timezone-aware dates to reduce ambiguity in agents, schedulers, and chatbots.
Why you might care:
- Fewer ambiguous instructions ("next Tuesday" -> 2025-09-23)
- Works across timezones/locales
- Choose formatting strategy: preserve, normalize, or hybrid
Quick example:
```
enhancePrompt("Schedule a demo next Tuesday and remind me tomorrow")
→ "Schedule a demo next Tuesday (2025-09-23) and remind me tomorrow (2025-09-16)"
```
Links:
- Project: https://time-ai.blueprintlab.io
- GitHub: https://github.com/BlueprintLabIO/time-ai
- NPM: https://www.npmjs.com/package/@blueprintlabio/time-ai
Would love feedback on real-world prompts, tricky date phrases, and missing patterns.

value: Show HN: Time-aware utilities for LLM prompts (TypeScript)


value: beefive

value: Built a job board that allows users to browse curated job listings by categories such as FAANG, Fintech, AI, Ecommerce, and Social Media, making it easy to filter roles by industries of interest

value: Show HN: Browse tech jobs by category – FAANG, Fintech, AI, Ecommerce

author: beefive


value: coryli

value:
I’m a contributor to StripeMeter, a tiny open-source tool to prove Stripe usage invoices are correct before they finalize.
What it does (small surface):
- POST /v1/replay — reconcile late/duplicate events (dry-run or apply)
- GET /v1/reconciliation/summary — see drift and counters before/after
- GET /v1/usage/history — time-series to visualize the effect
Why: real systems have retries, late events, and dupes. StripeMeter sits beside your billing/pricing layer to ensure the numbers are exact pre-invoice.
Not: a pricing/plan/entitlement system or a warehouse.
Scope & limits: aimed at early/mid-stage SaaS on Stripe usage billing; local target ~10k late-event replay in ≤ ~2s (queue/workers recommended at scale).
Contributors & Feedback wanted: docs polish, SDKs (Node/Python), replay worker improvements, minimal visualizer, observability (Prom/Grafana), integrations. Check Good First Issues and our pinned Design Partners thread if you want to run a quick parity session.
If you haven't already, would you mind reading about HN's approach to comments and site guidelines?

value: Show HN: StripeMeter – pre-invoice parity for Stripe usage billing

author: coryli


value: KalanaPerera

value:
Hello HN,
My wife and I have been working on this project for quite some time. It’s an online resume and career tools platform called Magic CV. She has been handling the backend development, while I’ve been working on the frontend side.
Yesterday evening, we decided to make our platform 100% free for everyone. It currently includes:
- Up to 10 resumes
- Up to 10 cover letters
- Unlimited PDF downloads (no watermarks, no paywalls)
- Limited AI features
Roadmap
- Word format downloads (in progress)
- Job Tracker (in progress)
- Targeted resumes for specific jobs
- Custom prompts + ability to use your own AI API keys (stay free forever)
- Personal website builder
- Plus a few new ideas we’re exploring
Data* DB data is encrypted.
No sign-in required to try out the resume builder.
Monetization
Right now, most of the key features are completely free. If users need more resumes, targeted resumes, or extra AI usage, we offer one-time payment options.
We’re also considering enabling Google AdSense for free users (currently no ads). Not yet decided, would love HN’s feedback on this.
I’d really appreciate your thoughts, suggestions, feature requests.
GitHub issues are open here: https://github.com/KalanaPerera/magiccv.ai
Ask any questions you may have - happy to answer :)
Thanks!

value: Show HN: My wife and I built MagicCV.ai, a 100% free online resume builder

author: KalanaPerera


value: compiledpanda

value:
Hi there! We're John Clark and Trevor Huey. After nearly 20 years of trying to keep our own documentation up-to-date we built a tool to help us. Meet Hyaline!
For us the biggest pain point was keeping track of what documentation needed to be updated for each PR we landed, especially when our documentation was spread out across multiple repositories and documentation sites (both internal and customer facing). So we built Hyaline to extract documentation from any source and then identify which pieces of documentation should be updated. Hyaline uses an LLM to examine the contents of each pull request and then comments on the pull request with any recommended documentation updates it finds.
We also added an audit tool to run checks and an MCP server to make your documentation even more useful.
Instructions to quickly try out Hyaline are available here (1), or you can visit the website to read more about what Hyaline does and how it works.
Thanks!
(1) https://www.hyaline.dev/documentation/how-to/try-out-hyaline...

value: Show HN: Hyaline – Recommended documentation updates for every PR

author: compiledpanda


value: adrianshp

value: Show HN: Ship Reliable AI Agents by Simulating Conversations

author: adrianshp


value: stared

value:
Hi HN,
I've always been a fan of ggplot2. It's a fantastic charting library with a powerful grammar that encodes best practices for data visualization. My goal was to make it easily accessible to anyone, without requiring any installation.
Inspired by tools like JSFiddle, I created an interactive environment for R's dplyr (for data preparation) and ggplot2.
It's a purely frontend application, meaning everything runs directly in your browser. There's no backend for computation, and it works on both desktop and mobile.
This project is an open-source offshoot of Quesma Charts. We initially used WebAssembly to sandbox AI-generated code, and while we've since moved to a different solution (you can read about the "why" here: https://quesma.com/blog/sandboxing-ai-generated-code-why-we-...), I wanted to share the non-AI part with the community. The stack is WebR (R compiled to WebAssembly) and Vue.js. Much of the code was written with assistance from Claude, though the WebR integration required significant manual effort due to its novelty.
Give it a try!
Playground: https://quesmaorg.github.io/webr-ggplot-playground/
Repo (MIT): https://github.com/QuesmaOrg/webr-ggplot-playground

value: Show HN: Ggplot2 chart playground – in the browser with WebAssembly

author: stared


value: airylizard

value:
Hey y'all
Wanted to introduce Patient Glue, it's an all-in-one SMS platform for healthcare that integrated directly into your EHR.
Currently have an up to 3 month pilot for you to try it for free!
Unlike other service offerings, Patient Glue is made to be budget friendly with a flat-rate per number of seats and usage pricing model.
I added in some AI integrations which are configurable and some automated workflows to make the scheduling process easier.
Built this because I had worked at a smaller practice and the clinic literally couldn't afford those other options.
Check it out yourself, open for any and all feedback!
Remember, happy patients stick around!

value: Show HN: Patient Glue a more affordable SMS solution for healthcare that I built

author: airylizard


value: ethanYIAI

value:
Introduction and features of the website
ExpandImageAI is a web-based tool that uses AI outpainting to naturally expand the edges of an image without distortion. It’s designed for content creators, designers, marketers, and anyone who needs to adapt images to different formats like social media posts, ads, or banners. The interface is simple, fast, and requires no installation.
AI outpainting/uncrop: Expands image borders smoothly, avoiding stretched or duplicated artifacts.
Multiple aspect ratios: Supports popular formats like Instagram square, Stories, Facebook cover, and more.
Quick workflow: Upload → choose canvas → AI generate → download. Fast and user-friendly.
Free trial access: Limited free daily use with support for JPG, PNG, WebP up to 10 MB. No account required.
This is the second product I developed independently. I encountered a lot of difficulties during the process, but I still persisted in the end.
The tool is in trial.......
If you encounter any problems with this AI tool, please feel free to contact me. Thank you for your feedback!

value: Show HN: AI tool to expand and uncrop images seamlessly for any canvas size

author: ethanYIAI


value: gordonmattey

value: Show HN: Port42 – AI agents that build tools from your actual work patterns

author: gordonmattey


value: thasso

value: Hey HN! This is a fun/educational project I built to learn OS programming. I started working on it right after graduating high school last year and have been working on it on and off during my first year of university. It features a TCP/IP stack, an HTTP server, a RAM file system, a BIOS bootloader, paging and memory management, and concurrent tasks based on cooperative scheduling, along with a custom library. It's written in a C programming style focused on safety (based on a custom library of core abstractions) that's inspired by the writing of Chris Wellons (nullprogram.com).<p>There is a link to a test deployment in the README. The TCP/IP implementation is nowhere near perfect, of course, so there may be issues loading the page. I'm curious how the system holds up if this post gets any attention ;-)

value: Show HN: I wrote a from-scratch OS to serve my blog

author: thasso


value: rvivek

value:
I'm Vivek, co-founder/CEO of HackerRank (YC S11); You may know us as a hiring tool for developers/companies.
Over the years, we have built up deep expertise in generating programming challenges, and we are now using that to make coding models better.
Our first launch is Model Kombat -- an arena where you can directly compare anonymized coding models, side by side, on real problems.
* Pick an arena (Java, Python, etc.)
* Each battle has 3 rounds: see the problem + two model outputs -> vote on which you’d actually prefer
* Leaderboards + problem statements are updated weekly.
We already have 400+ challenges live, and our goal is to evolve toward real-world, multi-file challenges and robust tooling for coding model evaluation.
Try it now at: modelkombat.com
We’d love your feedback.

value: Show HN: ModelKombat – Arena-style battles for coding models

author: rvivek


value: abhimanyouknow

value: Show HN: I made a gamified iOS habit tracker to quantify relapses

author: abhimanyouknow


value:
hey hn — we’re hoshang & vishal, co-founders of airbook. it’s an ai-native workspace to build notebooks, dashboards, or even lightweight data apps — all from one place (https://www.airbook.io)
we used to run ops and analytics at saas startups and constantly found ourselves juggling 10 tools just to get one thing done - exploration in a notebook, kpis in a dashboard, and re-usable scripts or apps hacked together elsewhere. it was slow, fragmented, and repetitive.
with Airbook, you can connect to your database, warehouse, or even directly to saas tools if you don’t have an etl in place. once connected, you can ask the ai to build whatever you need: a notebook, a dashboard, or a data app.
the difference is that our ai is schema-aware. it doesn’t just spit out sql - it actually understands your schema, writes the queries, executes them, and can build visualizations with the built-in charting library. you stay in the loop — queries are editable and outputs are collaborative.
demo: https://youtu.be/hFp9J98p4_w
try it free: https://app.airbook.io/signup
we’re early in the journey and would love to hear your feedback :
- how useful is schema-aware ai in practice?
- what’s the first data product you’d try to spin up with this?
We're around to answer any questions you may have.

value: Show HN: Schema aware AI to build data products


value: oliverjanssen

value:
Back in August 2024 I launched Muky here - a locked-down audio player for kids that only worked with Apple Music. The #1 request was Spotify support, so here's v3.
The technical challenge was building a unified interface across both Apple Music and Spotify APIs while maintaining the same UX. Also implemented smart caching for offline sync across both services.
Due to Spotify's API quota limitations (https://developer.spotify.com/documentation/web-api/concepts...), users need to create their own Spotify app through the developer platform and connect it to Muky. It's an extra setup step, but then it works seamlessly.
I've tested this with users of varying technical expertise and the setup process has been manageable across skill levels.
This brings Muky to feature parity across the two largest music services while keeping the same safe, kid-focused experience. Parents control exactly what music and audiobooks kids can access, and your own streaming algorithms stay clean since kids aren't browsing your main account.
Looking for feedback from:
Parents: What features are still missing for your family's needs?
Technical folks: Better approaches for Spotify integration? The current developer app requirement feels clunky but seems necessary given API limits
Excited to hear your thoughts!

value: Show HN: Muky v3 – Added Spotify to my kid-friendly iOS audio player

author: oliverjanssen


value:
Hi HN — I built Mii Maker, a free, browser-based editor for creating Mii-style avatars. You can start instantly without sign-up and export images for profiles, socials, or docs.
What it does
 • No registration, free & unlimited usage; open the site and start creating.
 • Real-time preview while tweaking face/eyes/hair/clothes/accessories.
 • Export & share: save to your device (multiple formats) and use anywhere.
 • Works on desktop/tablet/phone with the same UI.
Why I built it
I often needed quick, playful avatars for profiles and team docs, but most tools had account gates or heavy installers. I wanted a lightweight web editor you can use in seconds.
What’s different
 • Starts instantly in the browser; keeps the flow fast for casual use.
 • Simple presets + fine controls so you can get “close enough” quickly.
 • Focused on export quality/usability rather than game-console import formats.
Limitations / notes
 • It’s an independent web tool and not affiliated with Nintendo. “Mii” refers to Nintendo’s customizable avatar concept introduced with the Wii; this project is a fan-style creator for general image use, not for importing into consoles.
 • Feature requests welcome (e.g., SVG export, batch variants, color palettes).

value: Show HN: Mii Maker – Free browser-based Mii avatar creator (no signup)


value: Show HN: Universal single-letter project commands to speed up your CLI workflow


value: lykhonis

value:
Hey, I'm Vlad, founder of Spyc (pronounced "spice"). I've been building this as a side project turned fulltime over the past few months, drawing from my own frustrations as a DIY investor juggling spreadsheets and apps that either lacked privacy or were bloated with features I didn't need. I'm actively working on it, iteratively adding and exploring new features to enhance the dashboard from a large list of ideas.
Spyc is a web app that lets you track your net worth and portfolio securely without storing any personal identifiable info. You upload your statements (PDFs or CSVs from brokers), it parses them ephemerally - processing in realtime and discarding the originals right after - and gives you visuals like allocation pies, performance lines, and heatmaps. It also runs simple simulations (e.g., Monte Carlo for projections). Everything's anonymized and stored under a hashed key from your Google signin, with a one-click delete option.
What sets it apart: No automatic integrations or data hoarding like many trackers. It's manual-upload only to keep control in your hands, focusing on privacy as the core. It's optimized for mobile too.
To try it out: Head to spyc.io - you can sign in with Google (no email/password setup) and start uploading sample data immediately. I've set up a demo mode with pre-loaded anonymized datasets if you want to poke around without your own files (just click "see sample statements" on the dashboard).
This is the first public share; no prior HN threads. Looking forward to your thoughts, bugs, or feature ideas - I'm here to discuss.

value: Show HN: Spyc – Privacy-First Investment Tracker for DIY Portfolio and Net Worth

author: lykhonis


value: Show HN: Alyx, a caffeine tracker with no accountability


value: furkansahin

value: Show HN: Bulletty

author: furkansahin

title: Show HN: Bulletty


value: thewojo

value:
I’ve been impressed with Claude Code but one thing that sometimes gets in the way in my workflows is the messy, mangled text that is shown when pasting text from the Claude Code terminal sessions. So I built an open-source utility that cleans extraneous white space, pipes, and other characters from your CC/Codex pastes.
For example, you can turn this:
`How can I create a Claude Code script that     │
│   cleans up extraneous characters and cleans up  │
 │   extra spaces, new lines, and other messiness   │
when I copy from Claude Code terminal          │
│   prompts or copy code from Claude Responses in  │
│   the Claude Code Terminal? It can make it       │
 │   hard to read, save, and reuse.
`<p>Into this:<p>`How can I create a Claude Code script that cleans up extraneous characters and cleans up extra spaces, new lines, and other messiness when I copy from Claude Code terminal prompts or copy code from Claude Responses in the Claude Code Terminal? It can make it hard to read, save, and reuse.
While this was built with Claude Code in mind it also works on Codex.`
Try it here: https://cleanclode.com
It’s 100% private (no data collection, tracking, completely open-source). If there’s anything you don’t like please just create a GitHub issue, contribute your change (https://github.com/TheJoWo/Clean-Clode), or comment here. Thanks and hope it’s helpful to some of you

value: Show HN: Clean Clode – Clean Messy Terminal Pastes from Claude Code and Codex

author: thewojo


value: pekingzcc

value: I made a little toy to roast twitter by using a rap song, it is fun, might still have some bugs. Anyway make a try and send me feedback

value: Show HN: Roast your Twitter using a Rap

author: pekingzcc

title: Show HN: Roast your Twitter using a Rap


value:
Hi HN,
I’ve been working on something I’d love to share: 47jobs (https://47jobs.com
) – a marketplace where you can hire AI agents to do tasks instead of human freelancers.
Why?
I kept noticing that many tasks on Upwork/Fiverr—coding, content generation, data analysis, automation—can now be handled by AI in minutes, not hours. But there wasn’t a platform built around hiring AI directly.
So I built 47jobs:
100% AI agents doing the work (no humans in the loop).
Jobs get delivered 10x faster, at transparent prices.
You can “hire” an agent for coding, automation, research, etc.
I’d love your thoughts:
Does a pure AI-agent marketplace make sense?
What types of jobs would you want AI agents to handle first?
Any UX or trust issues you’d expect with this model?
This is an early version, and I’m here to learn from your feedback.
Thanks!

value: Show HN: 47jobs – A Fiverr/Upwork for AI Agents


value: huntaub

value:
Hey everyone, I’m Hunter, the founder of Archil. Archil is transforming object storage, like Amazon S3, into infinite, local file systems that provide instant access to massive data sets.
Last year, we launched Archil’s NFS-based product publicly on Hacker News (https://news.ycombinator.com/item?id=42174204), and we were absolutely thrilled to see the response of this community.
Since our last launch, we took a 10 month company-wide bet to build our own, custom storage protocol to deliver true, local-like performance to cloud instances – by behaving closer to a block storage product. Today, we are excited to announce the public availability of this high-performance protocol. You can try it for free today with a single click at https://disk.new (docs at https://docs.archil.com).
After spending 10 years in the storage industry building products like Amazon’s Elastic File System and buying AWS storage on Netflix’s core storage team, I knew that developers faced tremendous problems using storage. Getting easy-to-use persistent storage on a Kubernetes cluster is non-trivial, determining how much storage an application needs can be impossible if it’s bursty, and companies are tired of overpaying for either very expensive storage (like EFS) or unused capacity (like with EBS).
From my time on EFS, I also knew that NFS was not the solution. Users were disappointed to see a 10x performance drop when they moved data from EBS to EFS to share it across multiple instances.
This is why we built Archil.
Archil is a pay-as-you-go disk that automatically grows with your application. Because it synchronizes your data bidirectionally to sources like your Amazon S3 buckets (and other S3-compatible locations), you can connect it instantly to existing data sets and use your file data directly from S3 itself.
When you mount an Archil disk, your instance connects to our managed caching fleet of instances with NVMe devices that provide read-through and write-back caching to your disk’s data sources, like S3. Because we designed a distributed, replicated, highly-durable cache, it’s a safe place for data to be stored before being written back to S3. We only charge users for data that’s actively in the cache, and when you aren’t using your disk, you don’t pay Archil anything.
We’re really excited about the early companies that we’re working with who are building cutting edge CI/CD workers, performing satellite image processing, building serverless Jupyter Notebooks, creating AI-native code sandboxes (have you ever tried to run git directly on an NFS share?), building best-in-class AI agents that use file systems instead of MCP tools, and helping to deliver core AI infrastructure like gateways and compute.
I’m excited to give you all access today, with no charges in the month of September, and I’d love any feedback on the product that you may have. If you’re interested in working on deep, technical problems in the core infrastructure space, we’re also hiring in San Francisco and would love to hear from you (see https://www.ycombinator.com/companies/archil/jobs/svfkDVv-fo...).

value: Show HN: Archil's one-click infinite, S3-backed local disks now available

author: huntaub


value:
Hi HN,
I’ve been building LLM Memory Notes (LLMMN), a hosted semantic memory layer that gives AI agents persistent, searchable memory via the Model Context Protocol (MCP). You can create “Memories” (containers) and save “Notes” (entries) that are indexed using AI embeddings; agents can then search by meaning (e.g., searching “database error” will find relevant notes about “PostgreSQL timeout” or “MySQL connection failed”)  .
To get started, sign up on llm‑memory.com, create a Memory in the web UI, and obtain your API token  . Add the server to your .mcp.json and use your MCP client’s ReadMcpResourceTool and AddNoteTool to query or add notes  ; the docs have a full Quick Start guide  . LLMMN is a hosted service (not open source), currently in a public beta with free early access; final pricing is still being determined  . We’d love feedback from anyone building agent tooling or experimenting with persistent context layers!

value: Show HN: LLM Memory Notes – semantic memory layer for AI agents (MCP)


value: yucelfaruksahan

value: Show HN: Tailkits UI, 200 Tailwind components

author: yucelfaruksahan


value: mmajzoobi

value:
I have been working on an open source hardware/software product over the last few years to enable developers to build ai-enabled embedded/hardware-integrated applications with ease.
In this video, I demo ai-enabled features of this open source product (called ubo pod).
Developers can use the existing foundations to create new powerful multi-modal (voice/vision) user experiences.
The software and hardware design resources can be accessed on my github repo:
https://github.com/ubopod
https://github.com/ubopod/ubo_app

value: Show HN: Demo of AI-enabled voice/vision features on open source hardware [video]

author: mmajzoobi


value: Show HN: Data with logic for modern AI and infra workflows


value: avighnay

value:
Hey HN! Just wrapped the first release after couple of months of iterative dialogue driven development using Google Gemini. The goal was to see if we can rebuild the core of our SaaS platform from Rust + Duktape (human coded) to NodeJS (AI coded). The experience has been very refreshing to say the least. The project is now open sourced.
Introducing Gingee, a GenAI authored javascript application server. 95% of code, documentation, test cases were completely authored by Google Gemini. No additional tools were used just the AI Studio chat window. The entire development process AI chat transcript is documented (Link below)
Demo Video: https://youtu.be/Ob85kM234hU?si=Wy0lWHNJWqL2tVdn
AI Transcripts: https://gingerhome.github.io/gingee-docs/docs/ai-transcript/

value: Show HN: Gingee – A GenAI Authored JavaScript App Server

author: avighnay


value: henryl

value:
Hey HN,
I’m Henry, cofounder and CTO at Span (https://span.app/). Today we’re launching AI Code Detector, an AI code detection tool you can try in your browser.
The explosion of AI generated code has created some weird problems for engineering orgs. Tools like Cursor and Copilot are used by virtually every org on the planet – but each codegen tool has its own idiosyncratic way of reporting usage. Some don’t report usage at all.
Our view is that token spend will start competing with payroll spend as AI becomes more deeply ingrained in how we build software, so understanding how to drive proficiency, improve ROI, and allocate resources relating to AI tools will become at least as important as parallel processes on the talent side.
Getting true visibility into AI-generated code is incredibly difficult. And yet it’s the number one thing customers ask us for.
So we built a new approach from the ground up.
Our AI Code Detector is powered by span-detect-1, a state-of-the-art model trained on millions of AI- and human-written code samples. It detects AI-generated code with 95% accuracy, and ties it to specific lines shipped into production. Within the Span platform, it’ll give teams a clear view into AI’s real impact on velocity, quality, and ROI.
It does have some limitations. Most notably, it only works for TypeScript and Python code. We are adding support for more languages: Java, Ruby, and C# are next. Its accuracy is around 95% today, and we’re working on improving that, too.
If you’d like to take it for a spin, you can run a code snippet here (https://code-detector.ai/) and get results in about five seconds. We also have a more narrative-driven microsite (https://www.span.app/detector) that my marketing team says I have to share.
Would love your thoughts, both on the tool itself and your own experiences. I’ll be hanging out in the comments to answer questions, too.

value: Show HN: AI Code Detector – detect AI-generated code with 95% accuracy

author: henryl


value:
Hey HN! I'm Salim, a content marketer, and I’m working on a website called [quizquestions.org](http://quizquestions.org/). It's my project for building the biggest library of quiz questions.
This is not a quiz website per se, but a library for people who make quizzes.
You see, I make quizzes occasionally. There are many quiz makers, but not many resources for quizzes. And most of the resources are just blogs. So I've wanted to create a more structured website just for this.
Here’s what the site offers at the moment:
- A quiz card: Instead of browsing them, you can get quiz questions in a quiz format
- Quiz categories: https://www.quizquestions.org/category
- AI question generator: https://www.quizquestions.org/question-generator
- A blog page for guides: https://www.quizquestions.org/guides
- Saving questions: To use them later for creating a quiz
- Sending questions: To send your own questions
- Statistics about categories: https://www.quizquestions.org/statistics
This is my first website, so any feedback is welcome!

value: Show HN: Quizquestions.org – A free library for quiz questions


value: skorudzhiev

value:
I use Google Keep a lot and always felt limited by how labels work - they’re flat and get messy once you have more than a handful. I wanted a way to organize them into nested folders, so I built a Chrome extension called SubKeep.
What it does:
- Adds a persistent sidebar to Google Keep
- Lets you create labels and nest them into sublabels (folders)
- Allows expand/collapse of sections, with state remembered across reloads
- Lets you toggle between SubKeep’s nested labels and Google Keep’s original labels
Runs entirely locally in the browser (no servers, no external storage)
Tech: Built with Svelte + Vite, packaged as a Chrome Extension (Manifest V3). State is stored only in chrome.storage.local.
Why I built it: Google Keep is my go-to note app, but I wanted better organization without moving to another tool. SubKeep scratches that itch.
What’s next:
- Backup/export for labels
- Possibly cloud sync (opt-in)
- Feedback-driven improvements
I’d love to hear your thoughts on whether this approach feels useful, or if you’ve hit the same frustrations with Keep.
Link: https://chromewebstore.google.com/detail/subkeep/mhikglflelk...
I hope that you find this useful.
Thanks in advance!

value: Show HN: SubKeep – Nested Labels for Google Keep (Chrome Extension)

author: skorudzhiev


value: alariccole

value: Despite Apple’s fairly clear warnings that their 3B 4K model is not for use as a chat app, I had to try anyway. There’s definitely plenty of work to do but it’s starting to become useful.<p>Happy to answer any questions about limitations, what it’s good at, and how to coax it. The safety guardrails and forced disneyfication make this especially challenging.

value: Show HN: An LLM chat app using Apple's FoundationModels

author: alariccole


value: kazitasnim

value:
I made a simple tool called TextGlitch.com that lets you generate “glitch text” (also known as Zalgo text).
It works by stacking Unicode combining characters on top of your text so it looks distorted, eerie, or chaotic. You can control the intensity of the glitch, copy the result instantly, and use it on social media, memes, or just for fun.
I built it as a side project because most glitch text sites were either overloaded with ads, outdated, or clunky. My goal was to make something clean, fast, and distraction-free.
Would love feedback on:
- How smooth/usable it feels compared to similar tools
- Ideas for features (e.g., styles, presets etc)
Thanks for checking it out!

value: Show HN: TextGlitch – A Glitch Text Generator]

author: kazitasnim


value: aclarembeau

value: Show HN: Restaurant Online Booking System

author: aclarembeau


value: AdityaGavit

value: Show HN: I Collected Every Emoticon I Could Find – All Mood and Generator

author: AdityaGavit


value: levihanlen

value: Show HN: WriteRush – The writing app that feels like a game

author: levihanlen


value: lakesare

value:
I have non-24-hour sleep disorder with a 25-hour cycle, and used to draw these calendars manually in Excel to track my shifting sleep schedule. Finally automated it.
Green cells show when you're awake. You can click any cell to toggle it (useful for marking unavailable times when sharing with others). The "padding hours" feature helps set buffer zones around sleep/wake times.
Been using this daily for months – thought others with non-24 might find it helpful too.

value: Show HN: Meresei – Calendar for Non-24 (Sleep-Wake Disorder)

author: lakesare


value: andyprevalsky

value:
Hi HN!
We are a group of YC founders sick of the hiring status quo. We're launching Canteen, a recruiting platform that makes hiring top technical talent ~10x faster, at a fraction of the cost of traditional agencies.
Instead of wrangling recruiters, you just tell Cursor/Claude:
“curl @https://recruiting.thecanteenapp.com and follow the instructions, I want a [your job description].”
From there, Canteen:
 • Ingests your job description
 • Searches across arXiv, GitHub, LinkedIn, EthResearch, etc. to find relevant technical talent
 • Uses our agentic communication layer to handle outreach + lead verification
 • Pipes warm, verified, hard-to-reach leads straight into your hiring funnel (email, CRM, calendar, etc.)
We’re building this because recruiting engineers shouldn’t require endless cold emails and bloated agency fees. Agents + open technical graphs unlock a faster, cheaper, and more direct way to hire.
Would love your thoughts and feedback!

value: Show HN: Canteen – Hire Engineers 10× Faster, at Half the Cost

author: andyprevalsky


value:
Hey everyone. After fiddling with creating execution environments, I created a visual EE builder!
Instead of hand-crafting YAML, you can:
* Choose from a few starter presets (e.g. Basic Automation, Network, Cloud)
* Pick a base image, add collections, Python deps, and system packages
* Export a ready-to-build package with one click
The idea is to make it easier (and less error-prone) to spin up custom EEs, especially for demos, labs, or quick prototyping.
It's at the MVP stage and probably has bugs so I'm open to any feedback.

value: Show HN: Visual Ansible EE Builder

title: Show HN: Visual Ansible EE Builder


value:
Hey everyone
We’ve just released v0.2.0 of should: a lightweight assertion library for Go with zero dependencies and expressive error messages.
This release brings several new assertions (e.g., BeError, BeWithin, BeSameTime), refactors for better type handling, and improved docs. We’ve also added support for formatted messages and streamlined some core functions based on user feedback.
Repo: https://github.com/Kairum-Labs/should
Feedback and suggestions are very welcome!

value: Show HN: Should v0.2.0 – debugging Go tests made easier


value:
This is Prompt Canvas - a simple, open-source web app that lets you visually build LLM prompt templates as YAML schemas and then generate complete prompts by populating values in the templates. It’s based on a single HTML file with no real privacy concerns and everything is portable thanks to YAML exports.
Check out the example in the dropdown and read the guide to see how it works:
https://promptcanvas.ml4den.com/
LLMs like structure and I found that generating prompts like this is an easy way of giving it to them. It can be useful if you’re doing a degree of prompt engineering and you want to test small variations in your prompts; or if you have a use case where you submit the same promps many times but with some input variations. I found that browsing to a YAML file and tweaking one parameter for a particular job is much cleaner than a web of Notion pages which is what I had before.
Some thought and iteration has gone into the templating engine but everything is still early stage! Some of it is opinionated, and some of it is meant to be quite extensible to different use cases. Let me know if it makes sense.
I built this mostly with Gemini 2.5 Pro out of my own necessity. Would love to know if it's useful for you! Feedback welcome; as are bugs and things on GitHub: https://github.com/ml4den/PromptCanvas

value: Show HN: I built a tool to visually manage my LLM prompt templates and save them


value: adriaanmulder

value:
Hey HN!
I built Ghostpipe because:
1. I like to keep data about my software in the codebase and under version control.
2. I don’t like always working in raw text files with domain specific languages (eg Terraform, Openapi, er diagrams).
Ghostpipe is an open source tool that creates a bridge between files in your codebase and applications using webrtc.
This lets developers work with user interfaces where appropriate, while still having access to the underlying raw text files.
A few side-benefits to this setup are:
1. AI agents are good at working with local text files, so we can keep using those.
2. Generally speaking, no signup or installation is needed to use Ghostpipe apps, because all relevant data is in the codebase.
I built a few demo apps with Ghostpipe support (Excalidraw & Swagger UI), and I hope this proof of concept spurs some interest in taking this idea further.
Thanks!

value: Show HN: Ghostpipe – Connect files in your codebase to user interfaces

author: adriaanmulder


value: vinniejames

value: Show HN: I built a decentralized protocol for predicting interest rate movement

author: vinniejames


value: danohn

value:
mcpcap is a modular Python MCP (Model Context Protocol) Server for analyzing PCAP files. mcpcap enables LLMs to read and analyze network PCAP's with protocol-specific analysis tools that accept local files or remote URLs as parameters.
Landing page: https://mcpcap.ai
Docs: https://docs.mcpcap.ai
GitHub: https://github.com/mcpcap/mcpcap

value: Show HN: I've just released my new open source MCP server called mcpcap

author: danohn


value: devtev

value: Show HN: Word Tower a daily word ladder game with scoring

author: devtev


value: toma-bomba

value:
I built Budgero because I was frustrated with YNAB being expensive, region-limited, and not privacy-focused.
Budgero is a budgeting app that’s privacy-first, supports multiple currencies, works offline, and gives you full control of your data.
You can try it here: https://demo.budgero.app/ (data not saved).
For anyone interested in getting into beta sign up at: https://my.budgero.app (I will be sending invites soon)
Feedback welcome!

value: Show HN: Budgero – a privacy-first budgeting app

author: toma-bomba


value: xnslx

value:
Most people struggle with what to post. The blank page is hard to beat. But I found that the next story is often hidden in the videos we already watch.
I built a tool called Mermaid Mind that mines story prompts from YouTube videos. Here’s the workflow I use:
- Step 1. Pick a video(Paste any YouTube link into Mermaid Mind.)
- Step 2. Collect themes
The tool extracts 50+ “pill tags” — condensed ideas or phrases from the video.
For example, from one talk I got:
•Confidence + Humility = Likability
•Go Twice As Slow As You Think
•Rule of Three
- Step 3. Expand into posts
Each tag becomes a writing prompt:
•Confidence + Humility → A story about earning trust.
•Go Twice As Slow → A lesson on slowing down for clarity.
•Surprise → A story about an unexpected pivot.
Instead of forcing an idea, I now have a story inventory I can dip into for LinkedIn posts, blog articles, or newsletters.
Why this helps?
Tips are easy to forget. Stories tend to stick. By turning video content into story prompts, I skip the “what should I write?” problem and move straight into writing.
The project is live here: https://yttomermaid.xyz
Feedback is welcome.

value: Show HN: I generate a week of posts from one YouTube video

author: xnslx


value: itruf

value: Show HN: I built a Swift lib for parsing structured JSON streamed from LLMs

author: itruf


value:
Hi HN,
Chew here, CTO at [Alphaus](https://alphaus.cloud/en/). We've been running a similar version of Luna at Alphaus, to cache really huge CSVs and PARQUETs in memory (hundreds of GBs per account across multiple files). It's written in Go, and uses DuckDB and Apache Arrow behind the scenes.
We're now at a point where a single VM's memory is really not enough to hold these huge files (the really hi-mem VMs are not yet available in our region) so we're thinking of distributing the cache across multiple hi-mem VMs (with disk spill-over). I've been "itching" to rewrite this software using a non-GC language, and so I thought it's a good timing to do an OSS version of it. I did consider C++ (and Zig) but I think Rust is a good fit here.
I've looked at [Ballista](https://github.com/apache/datafusion-ballista) actually as I'm quite familiar with DataFusion, and of course, MotherDuck, but the amount of custom duct-tapes we do behind the scenes made me think it's going to be worth the effort.
And so, sharing to you, "Luna". Still alpha-level, and still a lot of things missing, but the main goal is an easy-to-use, easy-to-deploy, columnar in-memory SQL server process, leveraging DuckDB and Apache Arrow, with more focus on cloud and object storage data. And a distributed/cluster version of Luna as well; sort of alternative to Ballista.

value: Show HN: Luna, an in-memory SQL server for object storage data


value: Codegres

value: Show HN: MSPaint for Android

author: Codegres

title: Show HN: MSPaint for Android


value: Show HN: WhatsApp SMS IVR Email SchedulerText


value: Show HN: Scientific Calculator for Android


value: owenmccadden

value: Show HN: SessionBase, save and share AI coding sessions

author: owenmccadden


value: rohannih

value: Would love any feedback

value: Show HN: I built a platform for long-form media recs (books, articles, etc.)

author: rohannih

story_text: Would love any feedback


value:
Hey all! npm-daycare is a simple NPM proxy built on Verdaccio which filters all packages that:
- are younger than 48h (it will just provide an old version instead)
- have fewer than 5,000 weekly downloads
https://github.com/stack-auth/npm-daycare
This is in response to the recent supply chain attacks that shattered the JavaScript ecosystem [1]. It's likely not a problem that will go away any time soon, so we figured we'd build something to protect against it.
Doing this on the proxy layer means it will work across the entire system, as proxies are set globally. In the future, we could also add more filters to the proxy.
To get started, just run the Docker container:

    docker run -d --rm --name npm-daycare -p 4873:4873 bgodil/npm-daycare

    npm set registry http://localhost:4873/
    pnpm config set registry http://localhost:4873/
    yarn config set registry http://localhost:4873/
    bun config set registry http://localhost:4873/

    npm view @types/node  # has recent updates
    npm view pgmock  # has <5,000 weekly downloads

Downside: npm-daycare won't show packages that are younger than 48h on its default config, so be aware of that when you try to update your packages to patch a zero-day exploit.
You probably also shouldn't rely on this as your only line of defense. Curious to hear what you think!
[1] https://news.ycombinator.com/item?id=45260741

value: Show HN: npm-daycare, an NPM proxy that filters out recent & small packages


value: awcode

value: Users Loop helps SaaS teams communicate with customers, capture feedback, and deliver world-class support - while replacing multiple expensive tools with one affordable platform.

value: Show HN: Users Loop – SaaS feedback, roadmaps and helpdesks

author: awcode


value: yamii

value:
Hi HN!! I'm a Chinese Translator, also a developer and I made this to solve my own problems. I got tired of waiting for official translations, so I built a tool that lets you read the original text and get a clean, consistent translation on the fly.
I am not a translator by trade and that's probably why I have a different opinion than most translators for using clankers to translate, I have always felt that we should not be limited by language when it comes to wanting to read, this tool is mostly for people who do not want to wait for official translations and have a copy/purchase of the ebook in its original language.
How it works
1) Upload your own EPUB/TXT you have access to
2) Batch translate chapters with glossary support so names/terms stay consistent
3) Wait for the completion email and then download the completed translation for your personal use.
Works well for fiction, but also handles non-fiction books, I am working with a team and other translators to constantly improve the output.

value: Show HN: I built a tool to translate Chinese, Japanese, & Korean Novels

author: yamii


value:
So, after years of abandoning Rust after the hello world stage, I finally decided to do something substantial. It started with simple line rendering, but I liked how it was progressing so I figured I could make a reasonably complete PSX style renderer and a game with it.
My only dependency is SDL2; I treat it as my "platform", so it handles windowing, input and audio. This means my Cargo.toml is as simple as:
[dependencies.sdl2]
version = "0.35"
default-features = false
features = ["mixer"]
this pulls around 6-7 other dependencies.
I am doing actual true color 3D rendering (with Z buffer, transforming, lighting and rasterizing each triangle and so on, no special techniques or raycasting), the framebuffer is 320x180 (widescreen 320x240). SDL handles the hardware-accelerated final scaling to the display resolution (if available, for example in VMs it's sometimes not so it's pure software). I do my own physics, quaternion/matrix/vector math, TGA and OBJ loading.
Performance: I have not spent a lot of time on this really, but I am kind of satisfied: FPS ranges from [200-500] on a 2011 i5 Thinkpad to [70-80] on a 2005 Pentium laptop (this could barely run rustc...I had to jump through some hoops to make it work on 32 bit Linux), to [40-50] on a RaspberryPi 3B+. I don't have more modern hardware to test.
All of this is single threaded, no SIMD, no inline asm. Also, implementing interlaced rendering provided a +50% perf boost (and a nice effect).
The Pentium laptop has an ATI (yes) chip which is, maybe not surprisingly, supported perfectly by SDL.
Regarding Rust: I've barely touched the language. I am using it more as a "C with vec!s, borrow checker, pattern matching, error propagation, and traits". I love the syntax of the subset that I use; it's crystal clear, readable, ergonomic. Things like matches/ifs returning values are extremely useful for concise and productive code. However, pro/idiomatic code that I see around, looks unreadable to me. I've written all of the code from scratch on my own terms, so this was not a problem, but still... In any case, the ecosystem and tooling are amazing. All in all, an amazing development experience. I am a bit afraid to switch back to C++ for my next project.
Also, rustup/cargo made things a walk in the park while creating a deployment script that automates the whole process: after a commit, it scans source files for used assets and packages only those, copies dependencies (DLLs for Win), sets up build dependencies depending on the target, builds all 3 targets (Win10_64, Linux32, Linux64), bundles everything into separate zips and uploads them to my local server. I am doing this from a 64bit Lubuntu 18.04 virtual machine.
You can try the game and read all info about it on the linked itch.io page:
https://totenarctanz.itch.io/a-scavenging-trip
All assets (audio/images/fonts) where also made by me for this project (you could guess from the low quality).
Development tools: Geany (on Linux), notepad++ (on Windows), both vanilla with no plugins, Blender, Gimp, REAPER.

value: Show HN: A PSX/DOS style 3D game written in Rust with a custom software renderer


value: freakynit

value:
Motivated by recent supply-chain attacks in the npm ecosystem, I built a lightweight bash tool to run nodejs scripts safely inside docker.
It keeps node_modules in a persistent docker volume and blocks network access by default, so you can install and test packages without polluting your system.
Repo: https://github.com/freakynit/simple-npm-sandbox

value: Show HN: Simple sandboxed way to install and run Node.js scripts using Docker

author: freakynit


value: Viaya

value:
Hi HN,
I’m excited to share HuMo AI, an AI-driven tool that helps creators easily produce realistic, human-centric videos. HuMo AI supports text, image, and audio inputs, turning simple ideas into fully customized, lifelike content.
Key Features:
Multi-Input Support: Combine text, images, and audio to generate videos.
Realistic Results: Lifelike videos with perfect synchronization.
Perfect for Storytelling: Ideal for immersive experiences, education, and character creation.
Full Customization: Tailor every element, from appearance to actions.
HuMo AI uses an advanced AI reasoning engine, making it highly versatile for various creative tasks. Whether for gaming, education, or marketing, it offers a new level of freedom and control for creators.
The main challenge was integrating different input types to maintain synchronization and consistency. We’re continuously refining this, and we’d love your feedback.

value: Show HN: HuMo AI – Create Realistic Videos with Text, Image, and Audio Inputs

author: Viaya


value: bytenomad

value: Show HN: I built USJobs.fyi for youngsters to explore different careers

author: bytenomad


value: Show HN: A Simplest Single Page Application (SPA) Library for Alpine.js


value: The best free online tool to convert your Markdown (.md) files to Word (.docx) documents. No registration, Fast, high-quality conversion with just one click.

value: Show HN: Markdown to Word – Free Online Converter


value: chaidhat

value: I am new to js, so please go all out w/ the roasting.

value: Show HN: I built my own ORM – roast my code?

author: chaidhat


value: RhinoDevel

value:
For speech-to-text, large-language-model inference and text-to-speech I created three wrapper libraries in C/C++ (using Whisper.cpp, Llama.cpp and Piper).
Follow the URL to see an example that shows how to use these libraries for a speech-to-text, LLM inference, text-to-speech pipeline.
Windows and Linux are supported.

value: Show HN: STT –> LLM –> TTS pipeline in C

author: RhinoDevel