value: easysolpro

value: Show HN: SpecFlow – I added a "Bad Cop" auditor to Claude Code

author: easysolpro


value: ulyssepence

value:
Back story:
I've been learning computer graphics on the side for several years now and gain so much joy from smooshing and stretching images/videos. I hope you can get a little joy as well with Fuzzy Studio!
Try applying effects to your camera! My housemates and I have giggled so much making faces with weird effects!
Nothing gets sent to the server; everything is done in the browser! Amazing what we can do. I've only tested on macOS... apologies if your browser/OS is not supported (yet).

value: Show HN: Fuzzy Studio – Apply live effects to videos/camera

author: ulyssepence


value: ScioNos

value:
Hi HN!
Moonshot AI released Kimi K2.5 today, and we integrated it on RouterLab within hours.
Why this matters:
*Open source beats proprietary:*
• Kimi K2.5: 50.2% on HLE (Humanity's Last Exam)
• GPT-5: 41.7%
• Claude 4.5: 32.0%
First time an open-source model beats GPT-5 on expert-level reasoning.
*Agent Swarm architecture:*
• Orchestrates up to 100 parallel agents
• 1,500 simultaneous tool calls
• 4.5x faster than sequential execution
• Autonomous task decomposition
Example: "Analyze 50 competitors and create a report"
→ Creates 50 research agents
→ Parallel execution
→ Compiled report in minutes
*Technical specs:*
• 1T parameters (32B activated)
• 384 experts MoE
• INT4 quantization native
• 256k context window
• Open weights on Hugging Face
*Benchmarks:*
• HLE (reasoning): 50.2% (GPT-5: 41.7%)
• BrowseComp (web nav): 60.2% (GPT-5: 54.9%)
• SWE-Bench (coding): 71.3%
• VideoMMMU: 86.6%
*Pricing:*
• $0.60/$3.00 per 1M tokens
• 5x cheaper than GPT-5
We're a Swiss company (Eyelo SA, founded 1983) and integrated Kimi K2.5 on RouterLab with Swiss/German hosting for GDPR compliance.
OpenAI-compatible API, migration is 2 lines of code:
```python
client = OpenAI(
    base_url="https://routerlab.ch/v1",
    api_key="your-key"
)
I wrote a technical analysis:
https://medium.com/@comeback01/kimi-k2-5-the-agent-swarm-rev...
Try it: https://routerlab.ch/blog/kimi-k2-5 (14-day free trial)
Happy to answer technical questions about Agent Swarm, MoE architecture, or deployment!

value: Show HN: Kimi K2.5 (Agent Swarm, beats GPT-5) now on RouterLab (Swiss hosting)

author: ScioNos


value: Show HN: I vibecoded an X64, ARM64 operating system that boots on real hardware


value: emcodes

value:
Weekend project exploring what TypeScript looks like when small, fast LLMs are cheap enough to embed at the type level.

  // Parse natural language
  await SemanticNumber.from("about a dozen") // 12
  await SemanticDate.from("next Monday") // 2025-02-03
  await SemanticBoolean.from("yeah I guess so") // true, confidence: 0.7

  // Classify and validate with plain English
  await message.classify(['question', 'complaint', 'feedback', 'request'])
  await input.validate(["must be valid email", "must not contain profanity"])

  // Context-aware operations
  SemanticNumber.from(150).isReasonable("human age")
  // { reasonable: false, explanation: "Human age rarely exceeds 120" }

  // Same error, different audiences
  error.explain("end-user")   // "We couldn't connect. Check your internet."
  error.explain("developer")  // "ECONNREFUSED on port 5432..."

15+ types: boolean, number, string, array, date, error, URL, promise, map, set, etc.
Alpha—feedback welcome on what feels useful vs gimmicky.
https://github.com/elicollinson/semantic-primitives

value: Show HN: Semantic Primitives- TypeScript types that understand natural language

author: emcodes


value: volkina

value:
Hey HN, I built a CLI tool that automates compliance checks locally before you ship.
What it does:
- Validates ClickTag syntax and structure.
- Enforces file size limits and asset checks (magic numbers).
- AI-Native: Includes a built-in MCP server, allowing AI agents like Cursor to run validations directly in your workflow.
The core CLI is free on NPM: npm i -g @ad-preflight/cli
Feedback on the MCP integration is welcome.

value: Show HN: Ad-Preflight – A CLI to Validate HTML5 Ads (Google/DV360 Compliance)

author: volkina


value: ykushch

value: Show HN: ask - Talk to your shell in natural language (runs locally with Ollama)

author: ykushch


value: yol

value:
How existing prompt management solutions work bothers me, it seems to go against programming best practices: the prompt templates are stored in completely separate system from its dependencies, and there’s no interface definitions for using them. It’s like calling a function (the prompt template) that takes ANY arguments and can silently return crap when the arguments don’t align with its internal implementation.
So I made this project according to how I think prompt management should work - strongly typed interface, defined in the code; the prompt templates are co-located in the same codebase as their dependencies; and there’s type-hint and validation for devEx. Doing this also brings additional benefit: because the variables are strong typed at compose time, it’s save to support complex prompt templates with if/else/for control loops with full type safety.
I’d love to know whether this resonate with others, or is it just my pet peeve.

value: Show HN: Pixie-prompts – manage LLM prompt templates like code

author: yol


value: vvoruganti

value:
Hey HN,
It’s Vineeth from Plastic Labs. We've been building Honcho, an open-source memory library for stateful AI agents.
Most memory systems are just vector search—store facts, retrieve facts, stuff into context. We took a different approach: memory as reasoning. (We talk about this a lot on our blog)
We built Neuromancer, a model trained specifically for AI-native memory. Instead of naive fact extraction, Neuromancer does formal logical reasoning over conversations to build representations that evolve over time. Its both cheap ( $2/M tokens ingestion, unlimited retrieval), token efficient and SOTA: LongMem (90.4%), LoCoMo (89.9%), and BEAM. On BEAM 10M—which exceeds every model's context window—we hit 0.409 vs prior SOTA of 0.266, using 0.5% of context per query.
Github: https://github.com/plastic-labs/honcho
Evals: https://evals.honcho.dev
Neuromancer Model Card: https://plasticlabs.ai/neuromancer)
Memory as Reasoning Approach: https://blog.plasticlabs.ai/blog/Memory-as-Reasoning
Read more about our recent updates: https://blog.plasticlabs.ai/blog/Honcho-3
Happy to answer questions about the architecture, benchmarks, or agent memory patterns in general

value: Show HN: Honcho – Open-source memory infrastructure, powered by custom models

author: vvoruganti


value: Evanson

value:
Hey HN! I built Lumina – an open-source observability platform for AI/LLM applications. Self-host it in 5 minutes with Docker Compose, all features included.
The Problem:
I've been building LLM apps for the past year, and I kept running into the same issues:
- LLM responses would randomly change after prompt tweaks, breaking things.
- Costs would spike unexpectedly (turns out a bug was hitting GPT-4 instead of 3.5).
- No easy way to compare "before vs after" when testing prompt changes.
- Existing tools were either too expensive or missing features in free tiers.
What I Built:
Lumina is OpenTelemetry-native, meaning:
- Works with your existing OTEL stack (Datadog, Grafana, etc.).
- No vendor lock-in, standard trace format.
- Integrates in 3 lines of code.
Key features:
 - Cost & quality monitoring – Automatic alerts when costs spike, or responses degrade.
 - Replay testing – Capture production traces, replay them after changes, see diffs.
 - Semantic comparison – Not just string matching – uses Claude to judge if responses are "better" or "worse."
 - Self-hosted tier – 50k traces/day, 7-day retention, ALL features included (alerts, replay, semantic scoring)
How it works:
```bash
# Start Lumina
git clone <a href="https://github.com/use-lumina/Lumina" rel="nofollow">https://github.com/use-lumina/Lumina</a>
cd Lumina/infra/docker
docker-compose up -d
```
```typescript
// Add to your app (no API key needed for self-hosted!)
import { Lumina } from '@uselumina/sdk';<p>const lumina = new Lumina({
  endpoint: 'http://localhost:8080/v1/traces',
});<p>// Wrap your LLM call
const response = await lumina.traceLLM(
  async () => await openai.chat.completions.create({...}),
  { provider: 'openai', model: 'gpt-4', prompt: '...' }
);
```
That's it. Every LLM call is now tracked with cost, latency, tokens, and quality scores.
What makes it different:
1. Free self-hosted with limits that work – 50k traces/day and 7-day retention (resets daily at midnight UTC). All features included: alerts, replay testing, and semantic scoring. Perfect for most development and small production workloads. Need more? Upgrade to managed cloud.
2. OpenTelemetry-native – Not another proprietary format. Use standard OTEL exporters, works with existing infra. Can send traces to both Lumina AND Datadog simultaneously.
3. Replay testing – The killer feature. Capture 100 production traces, change your prompt, replay them all, and get a semantic diff report. Like snapshot testing for LLMs.
4. Fast – Built with Bun, Postgres, Redis, NATS. Sub-500ms from trace to alert. Handles 10k+ traces/min on a single machine.
What I'm looking for:
- Feedback on the approach (is OTEL the right foundation?)
- Bug reports (tested on Mac/Linux/WSL2, but I'm sure there are issues)
- Ideas for what features matter most (alerts? replay? cost tracking?)
- Help with the semantic scorer (currently uses Claude, want to make it pluggable)
Why open source:
I want this to be the standard for LLM observability. That only works if it's:
- Free to use and modify (Apache 2.0)
- Easy to self-host (Docker Compose, no cloud dependencies)
- Open to contributions (good first issues tagged)
The business model is managed hosting for teams that don't want to run infrastructure. But the core product is and always will be free.
Try it:
- GitHub: https://github.com/use-lumina/Lumina
- Docs: https://docs.uselumina.io
- Quick start: 5 minutes from `git clone` to dashboard
I'd love to hear what you think! Especially interested in:
- What observability problems are you hitting with LLMs
- Missing features that would make this useful for you
- Any similar tools you're using (and what they do better)
Thanks for reading!

value: Show HN: Lumina – Open-source observability for AI systems(OpenTelemetry-native)

author: Evanson


value: aschuth

value:
I wanted my team to start using Claude Code but didn't want to set everyone up before they were convinced. Started piping output to Mattermost (and later Slack) so people could watch and learn how to work with Claude Code.
Ended up building more: multiple sessions in parallel (each in a thread, hence the name), approve messages from other users with emojis, approve file writes, attach images/files, worktrees per thread.
It runs on your machine.
I built most of it using itself. Teammates watching live caught stuff I missed.
https://claude-threads.run
https://github.com/anneschuth/claude-threads

value: Show HN: Claude Threads – Collaborate on Claude Code via Slack (Or Mattermost)

author: aschuth


value: mfolaron

value: Show HN: ChatGPT like group chats for Claude, Gemini and Grok

author: mfolaron


value: tsenart

value: Show HN: Gilfoyle. An SRE Agent that finds truth while you're still guessing

author: tsenart


value: codesleep

value: Show HN: AI-generated image resizing tool (browser-based, 100% private)

author: codesleep


value: mrkaluzny

value: Show HN: Free IndexNow URL Submission Tool - Bulk Submit URLs to Bing, Yandex

author: mrkaluzny


value: gatinsama

value:
Hello HN,
I built MakeWay (https://getmakeway.com) because many of my friends were tired of managing client projects through a mix of email threads, shared drive links, and instant messages. They were especially tired of instant messages.
Most client portals seem to be either file storage solutions (Dropbox-style) or complex project management suites (Jira-style). I wanted something in between: a portal with a dedicated "Space" for each client or project.
What it does:
MakeWay lets you create a portal where you and your clients can exchange messages, files, and events. It works for internal communications too.
It is designed for asynchronous communication in threaded, organized discussions.
How it works:
1. Spaces: You create a Space for a client or project.
2. Access: Everyone uses magic links (or OTP).
3. Interaction: All messages, files, and calendar events for that project happen inside that Space.
4. Notifications: Not a lot. You only notify clients and clients notify you manually, ping-style.
5. Messages: You can close threads so communication is more organized.
Tech Stack:
- Frontend: SvelteKit (SPA, SSG) hosted on Cloudflare Pages.
- Backend: Django Rest Framework on a VPS (Hetzner).
- Database: PostgreSQL.
Try it out:
You can try the full app in Demo Mode without a credit card.
1. Go to https://app.getmakeway.com
2. Enter an email to "Sign Up" (it uses magic links).
3. Create a new Company (it will be in Demo Mode). Note that in Demo Mode, outgoing emails are blocked to prevent abuse, so you can test safely.
Feedback Requested:
I'm a solo dev bootstrapping this. I'd appreciate feedback on:
1. The "Spaces" model: Does this conceptual model make sense for your client interactions?
2. Onboarding: Was the passive "Demo Mode" clear enough?
3. Features: What features are missing? Folders or tags next? Public files for easier client onboarding? I have a huge backlog!
Thanks a ton!
Link: https://getmakeway.com

value: Show HN: MakeWay is a simple async client portal

author: gatinsama


value: kelguerin

value:
Hi all — I'm Kel, VP of Platform at Fauna Robotics. We're coming out of stealth and shipping Sprout (Creator Edition) today: a developer-ready humanoid robot built to be safe, approachable, and capable.
We set out to build Sprout because we believe robots belong around people. Too many humanoids still feel like heavy machinery that doesn't belong in human spaces, and even the “friendlier” ones force teams to spend their time rebuilding baseline hardware and software instead of real applications. Sprout is different: lightweight and soft-bodied (1.07m / 22.7kg), with compliant control + active safety sensing, and designed to feel more like the robots we trust in our imaginations, like Baymax or Wall-E—expressive, emotionally legible, and built for natural interaction and HRI work.
Sprout is a canvas for developers, with thoughtfully designed core capabilities and a fully featured SDK, so you can focus on what excites you. Out of the box, it can walk, kneel, crawl, and sit, map, localize, and navigate real environments, and supports full-body teleoperation and manipulation with integrated grippers and a stereo camera. We also provide simulation assets for Isaac Sim and MuJoCo, and include an MCP server so any of the robot’s functionality can be driven by the LLM or agent of your choice. You have everything you need to train your own manipulation policy, create a tour guide, build an emotive story-teller, and you can easily add your own modules to build whatever else you can imagine.
Sprout is already in use with groups across entertainment and research, including Disney, Boston Dynamics, UCSD, and New York University, and we would love to hear what you would build with Sprout!
Specs, videos, our platform paper, and a request form are up on our site: https://www.faunarobotics.com

value: Show HN: Sprout, a fun-sized, developer-ready humanoid robot

author: kelguerin


value: justvugg

value:
I built PolyMCP, a framework that lets you transform any Python or TypeScript function into an MCP (Model Context Protocol) tool ready to be used by AI agents — no rewriting, no complex integrations.
Examples
Python function:
from polymcp.polymcp_toolkit import expose_tools_http
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b
app = expose_tools_http([add], title="Math Tools")
Run with:
uvicorn server_mcp:app --reload
AI agents can now call add(3, 4) directly.
TypeScript function:
import { z } from 'zod';
import { tool, exposeToolsHttp } from 'polymcp';
const uppercaseTool = tool({
  name: 'uppercase',
  description: 'Convert text to uppercase',
  inputSchema: z.object({ text: z.string() }),
  function: async ({ text }) => text.toUpperCase(),
});
const app = exposeToolsHttp([uppercaseTool], { title: "Text Tools" });
app.listen(3000);
Agents can call uppercase("hello") and get "HELLO" instantly.
Business workflow function (Python example):
import pandas as pd
from polymcp.polymcp_toolkit import expose_tools_http
def calculate_commissions(sales_data: list[dict]):
    df = pd.DataFrame(sales_data)
    df["commission"] = df["sales_amount"] * 0.05
    return df.to_dict(orient="records")
app = expose_tools_http([calculate_commissions], title="Business Tools")
Now AI agents can generate reports automatically.
Why it matters
 • Reuse existing code immediately: legacy scripts, internal libraries, APIs.
 • Automate workflows: AI can orchestrate multiple tools reliably.
 • Cross-language: expose Python and TypeScript functions on the same MCP server.
 • Plug-and-play: no custom wrappers or middleware needed.
 • Built-in reliability: input/output validation and error handling included.
PolyMCP makes any Python or TypeScript function immediately usable by AI agents, standardizing integration across enterprise software.
Repo: https://github.com/poly-mcp/Polymcp

value: Show HN: PolyMCP – Expose Python and TypeScript Functions as MCP Tools

author: justvugg


value: Show HN: Convert 3MF to STL Free Online Tool


value: devonkelley

value:
Hey HN, we’re Devon and Alex from Kalibr (https://kalibr.systems).
Kalibr is an autonomous routing system for AI agents. It replaces human debugging with an outcome-driven learning loop. On every agent run, it decides which execution path to use based on what is actually working in production.
An execution path is a full strategy, not just a model: model + tools + parameters.
Most agents hardcode one path. When that path degrades or fails, a human has to notice, debug, change configs, and redeploy. Even then, the fix often doesn’t stick because models and tools keep changing.
I got tired of being the reliability layer for my own agents. Kalibr replaces that.
With Kalibr, you register multiple paths for a task. You define what success means. After each run, your code reports the outcome. Kalibr captures telemetry on every run, learns from outcomes, and routes traffic to the path that’s working best while continuously canarying your alternative paths. When one path degrades or fails, traffic shifts immediately. No alerts, no dashboards and no incident response.
How is this different from other routers or observability tools?
Most routers choose between models using static rules or offline benchmarks. Observability tools show traces and metrics but still require humans to act. Kalibr is outcome-aware and autonomous. It learns directly from production success and changes runtime behavior automatically. It answers not “what happened?” but “what should my agent do next?”
We’re not a proxy. Calls go directly to OpenAI, Anthropic, or Google. We’re not a retry loop. Failed paths are routed away from, not retried blindly. Success rate always dominates; cost and latency only matter when success rates are close.
Python and TypeScript SDKs. Works with LangChain, CrewAI, and the OpenAI Agents SDK. Decision latency is ~50ms. If Kalibr is unavailable, the Router falls back to your first path.
Think of it as if/else logic for agents that rewrites itself based on real production outcomes.
We’ve been running this with design partners and would love feedback. Always curious how others are handling agent reliability in production.
GitHub: https://github.com/kalibr-ai/kalibr-sdk-python
Docs & benchmarks: https://kalibr.systems/docs

value: Show HN: Kalibr – Autonomous Routing for AI Agents

author: devonkelley


value: vddev

value: Show HN -ProdSensor –Scans your code and predicts where it'll break on prod load

author: vddev


value: onurkanbkrc

value: Show HN: promptmeter – LLM powered terminal load testing via prompts

author: onurkanbkrc


value: Show HN: Kurbelfahrplan, a FOSDEM schedule app for the playdate


value: Zvizr

value: Show HN: Pingram – Send Telegram alerts with 1 line of Python (20KB)

author: Zvizr


value: kpam

value:
We built Dexicon because there's invaluable context in AI coding sessions that disappears the moment you close the tab. Architectural decisions, debugging rabbit holes, the "why we did it this way" - gone.
Dexicon captures sessions from Claude Code, Cursor, Codex, and others, then makes it all searchable via MCP. You can also upload sessions manually along with relevant docs. It extracts atomic pieces of context into a knowledge graph - for V1, that means completed tasks and debugging/root-cause analyses, the non-trivial stuff that helps when someone hits the same issue a few weeks later.
It's designed to be useful for solo devs who want searchable insights into their own sessions, but scales to teams as a way to solve the tribal knowledge problem.
We're pre-seed with a handful of paying customers. The developers we've been working with have surprised us with use cases we didn't anticipate: encoding team best practices, speeding up onboarding for new teammates, and generating optimized agent instructions from their own session history.
Now we're opening up access to more users and would love feedback from HN community.

value: Show HN: Dexicon – Capture AI coding sessions so your team never loses context

author: kpam


value: Charmunk

value: Show HN: YAFS – Yet Another File Server

author: Charmunk

title: Show HN: YAFS – Yet Another File Server


value: Show HN: A unified API for electronic component pricing (Mouser, DigiKey, TME)


value: irasigman

value: Show HN: Systematic Query Language for Quant Research with AI

author: irasigman


value: kariopaul

value:
DocEndorse is an AI-powered e-signature assistant that lets you prepare, send, track, and follow up on documents through natural language instead of forms and drag-and-drop editors.
You can tell it what you want (“Send this NDA to John for signature”), and it will:
 • Find the right document and contacts
 • Detect and place signing fields
 • Assign signer roles
 • Suggest titles and messages
 • Send requests via email, SMS, WhatsApp, or Microsoft Teams
 • Track status and automatically follow up with signers
It supports the full e-signature lifecycle: self-signing, sending requests, templates, reminders, resends, and real-time status updates. Follow-ups are generated automatically with tone and timing adjusted based on progress.
Deeply integrated with Microsoft 365: OneDrive, SharePoint, Outlook contacts, and Teams chats/meetings. Everything can be done through a conversational interface, with a dashboard for centralized visibility.
Target users: teams and enterprises that handle frequent approvals, contracts, onboarding, legal docs, or vendor agreements and want to reduce manual prep and turnaround time.
Available as a Microsoft Teams app (personal scope) with an in-chat AI assistant plus dashboard. Free tier with monthly limits; upgrades available.
More info: https://docendorse.com
Help: https://docendorse.com/help

value: Show HN: DocEndorse – An AI assistant that runs your e-sign workflow in chat

author: kariopaul


value:
I built Lightbox because I kept running into the same problem: an agent would fail in production, and I had no way to know what actually happened.
Logs were scattered, the LLM’s “I called the tool” wasn’t trustworthy, and re-running wasn’t deterministic.
This week, tons of Clawdbot incidents have driven the point home. Agents with full system access can expose API keys and chat histories. Prompt injection is now a major security concern.
When agents can touch your filesystem, execute code, and browse the web…you probably need a tamper-proof record of exactly what actions it took, especially when a malicious prompt or compromised webpage could hijack the agent mid-session.
Lightbox is a small Python library that records every tool call an agent makes (inputs, outputs, timing) into an append-only log with cryptographic hashes. You can replay runs with mocked responses, diff executions across versions, and verify the integrity of logs after the fact.
Think airplane black box, but for your hackbox.
*What it does:*
- Records tool calls locally (no cloud, your infra)
- Tamper-evident logs (hash chain, verifiable)
- Replay failures exactly with recorded responses
- CLI to inspect, replay, diff, and verify sessions
- Framework-agnostic (works with LangChain, Claude, OpenAI, etc.)
*What it doesn’t do:*
- Doesn’t replay the LLM itself (just tool calls)
- Not a dashboard or analytics platform
- Not trying to replace LangSmith/Langfuse (different problem)
*Use cases I care about:*
- Security forensics: agent behaved strangely, was it prompt injection? Check the trace.
- Compliance: “prove what your agent did last Tuesday”
- Debugging: reproduce a failure without re-running expensive API calls
- Regression testing: diff tool call patterns across agent versions
As agents get more capable and more autonomous (Clawdbot/Molt, Claude computer use, Manus, Devin), I think we’ll need black boxes the same way aviation does.
This is my attempt at that primitive.
It’s early (v0.1), intentionally minimal, MIT licensed.
Site: <https://uselightbox.app>
install: `pip install lightbox-rec`
GitHub: <https://github.com/mainnebula/Lightbox-Project>
Would love feedback, especially from anyone thinking about agent security or running autonomous agents in production.

value: Show HN: Lightbox – Flight recorder for AI agents (record, replay, verify)


value:
Hi HN!
I built (vibe coded) a completely browser-based watermarking tool that processes images and videos locally without any server uploads. Link: https://watermark.akatski.com
Everything runs client-side - React + Vite, deployed on Cloudflare Pages. No backend, no file uploads, no tracking (except GA).
Would love feedback on the UX and any performance improvements for video processing!
Built this because existing tools either require uploads (privacy concern) or cost money. Wanted something free that respects privacy.

value: Show HN: Watermark – Browser based image/video watermarking with FFmpeg.wasm


value: wduncan

value:
Tolerance uses an LLM to score social media posts by manipulation tactics (rage bait, engagement farming, emotional exploitation) and progressively blurs high-scoring content. The more a post tries to grab your attention, the harder it is to see.
I built it because I'd been fighting a doomscrolling habit for 15 years. Blockers never worked, I'd just override them. Tolerance broke the habit in two weeks. I still reflexively open Twitter and Reddit, but I close them in seconds because there's nothing rewarding there anymore.
I started feeling entitled to my own attention. Manipulation that I used to scroll past now feels like a violation. The less a post tries to grab you, the higher the actual value tends to be.
Open source (AGPL-3.0), free tier with BYOK, $9/month pro tier.
https://tolerance.lol  https://github.com/gtech/tolerance

value: Show HN: I built a tool that broke my 15-year doomscrolling habit in one week

author: wduncan


value: saisrirampur

value: Show HN: An open-source starter for developing with Postgres and ClickHouse

author: saisrirampur


value: Show HN: AnalysisXYZ – Browser-based CSV/Excel analyzer (privacy focused)


value: lcolucci

value:
Hey HN, we're the co-founders of LemonSlice (try our HN playground here: https://lemonslice.com/hn). We train interactive avatar video models. Our API lets you upload a photo and immediately jump into a FaceTime-style call with that character. Here's a demo: https://www.loom.com/share/941577113141418e80d2834c83a5a0a9
Chatbots are everywhere and voice AI has taken off, but we believe video avatars will be the most common form factor for conversational AI. Most people would rather watch something than read it. The problem is that generating video in real-time is hard, and overcoming the uncanny valley is even harder.
We haven’t broken the uncanny valley yet. Nobody has. But we’re getting close and our photorealistic avatars are currently best-in-class (judge for yourself: https://lemonslice.com/try/taylor). Plus, we're the only avatar model that can do animals and heavily stylized cartoons. Try it: https://lemonslice.com/try/alien. Warning! Talking to this little guy may improve your mood.
Today we're releasing our new model* - Lemon Slice 2, a 20B-parameter diffusion transformer that generates infinite-length video at 20fps on a single GPU - and opening up our API.
How did we get a video diffusion model to run in real-time? There was no single trick, just a lot of them stacked together. The first big change was making our model causal. Standard video diffusion models are bidirectional (they look at frames both before and after the current one), which means you can't stream.
From there it was about fitting everything on one GPU. We switched from full to sliding window attention, which killed our memory bottleneck. We distilled from 40 denoising steps down to just a few - quality degraded less than we feared, especially after using GAN-based distillation (though tuning that adversarial loss to avoid mode collapse was its own adventure).
And the rest was inference work: modifying RoPE from complex to real (this one was cool!), precision tuning, fusing kernels, a special rolling KV cache, lots of other caching, and more. We kept shaving off milliseconds wherever we could and eventually got to real-time.
We set up a guest playground for HN so you can create and talk to characters without logging in: https://lemonslice.com/hn. For those who want to build with our API (we have a new LiveKit integration that we’re pumped about!), grab a coupon code in the HN playground for your first Pro month free ($100 value). See the docs: https://lemonslice.com/docs. Pricing is usage-based at $0.12-0.20/min for video generation.
Looking forward to your feedback!
EDIT: Tell us what characters you want to see in the comments and we can make them for you to talk to (e.g. Max Headroom)
*We did a Show HN last year for our V1 model: https://news.ycombinator.com/item?id=43785044. It was technically impressive but so bad compared to what we have today.

value: Show HN: LemonSlice – Upgrade your voice agents to real-time video

author: lcolucci


value: yoitsmanan

value: There’s a short demo on the homepage showing it in action.

value: Show HN: Artemis – A proactive AI that you can literally call to get work done

author: yoitsmanan


value: robinbaertschi

value: Show HN: TypoGuard – A typosquatting monitoring engine with automated reporting

author: robinbaertschi


value:
Yes, absolutely.
In fact, the Simulator link is more important than your homepage link.
Here is why:
Hacker News users hate "Marketing": If they land on a homepage that says "Sign Up" or "Book a Demo," they will leave immediately.
They love "Toys": They want to click buttons and see the tech work right now.
The "No-Login" Rule: By explicitly saying "No Login Needed," you signal that you respect their time. This gets you upvotes.
Here is the final, clean version to copy-paste. I have made the Simulator link prominent.
Title: Show HN: CaseAI – Build custom RAG agents for WhatsApp in 2 minutes
Url: https://www.caseai.ai
Text (Body):
Hi HN,
I built CaseAI (https://www.caseai.ai) to make it easy for non-technical businesses to deploy "smart" agents on the official WhatsApp Cloud API.
The Problem: Millions of service businesses run entirely on WhatsApp but struggle with two things:
They can't answer leads instantly 24/7.
Standard "chatbots" are too rigid and "GPT wrappers" hallucinate too much for business use.
The Solution: CaseAI is a no-code platform where you can upload your business data (PDFs, price lists), and it spins up a dedicated WhatsApp Agent using RAG.
It handles the heavy lifting of:
Ingestion: Chunking and embedding uploaded documents.
Orchestration: Managing the WhatsApp Cloud API session window.
Handoff: Detecting when a human needs to intervene and pausing the AI.
Try it (No Login Required): I built a Live Simulator so you can test the RAG accuracy in the browser without needing to open WhatsApp: https://www.caseai.ai/#simulator-section
The Tech Stack:
Frontend: Next.js
Database: Drizzle ORM
Messaging: WhatsApp Cloud API (Meta)
Vector Search: Used for the RAG retrieval pipeline.
I’m looking for feedback on the retrieval latency and the quality of the generated answers. Thanks!


value: olivdums

value: Show HN: Duolingo for React Devs

author: olivdums

title: Show HN: Duolingo for React Devs


value: proshan

value: Open-source fuzzer for MCP servers. Goal: make it easy to repeatedly throw malformed/odd requests at servers and catch crashes, hangs, and bad error handling.<p>If you’re building an MCP server, I’d love to know what you’d want from a fuzzer (corpus inputs, transport coverage, reporting, CI usage).

value: Show HN: Fuzz testing tool for MCP servers

author: proshan


value:
Hi HN, I've been building Mystral Native — a lightweight native runtime that lets you write games in JavaScript/TypeScript using standard Web APIs (WebGPU, Canvas 2D, Web Audio, fetch) and run them as standalone desktop apps. Think "Electron for games" but without Chromium. Or a JS runtime like Node, Deno, or Bun but optimized for WebGPU (and bundling a window / event system using SDL3).
Why: I originally started by starting a new game engine in WebGPU, and I loved the iteration loop of writing Typescript & instantly seeing the changes in the browser with hot reloading. After getting something working and shipping a demo, I realized that shipping a whole browser doesn't really work if I also want the same codebase to work on mobile. Sure, I could use a webview, but that's not always a good or consistent experience for users - there are nuances with Safari on iOS supporting WebGPU, but not the same features that Chrome does on desktop. What I really wanted was a WebGPU runtime that is consistent & works on any platform. I was inspired by deno's --unsafe-webgpu flag, but I realized that deno probably wouldn't be a good fit long term because it doesn't support iOS or Android & doesn't bundle a window / event system (they have "bring your own window", but that means writing a lot of custom code for events, dealing with windowing, not to mention more specific things like implementing a WebAudio shim, etc.). So that got me down the path of building a native runtime specifically for games & that's Mystral Native.
So now with Mystral Native, I can have the same developer experience (write JS, use shaders in WGSL, call requestAnimationFrame) but get a real native binary I can ship to players on any platform without requiring a webview or a browser. No 200MB Chromium runtime, no CEF overhead, just the game code and a ~25MB runtime.
What it does:
- Full WebGPU via Dawn (Chrome's implementation) or wgpu-native (Rust)
- Native window & events via SDL3
- Canvas 2D support (Skia), Web Audio (SDL3), fetch (file/http/https)
- V8 for JS (same engine as Chrome/Node), also supports QuickJS and JSC
- ES modules, TypeScript via SWC
- Compile to single binary (think "pkg"): `mystral compile game.js --include assets -o my-game`
- macOS .app bundles with code signing, Linux/Windows standalone executables
- Embedding API for iOS and Android (JSC/QuickJS + wgpu-native)
It's early alpha — the core rendering path works well & I've tested on Mac, Linux (Ubuntu 24.04), and Windows 11, and some custom builds for iOS & Android to validate that they can work, but there's plenty to improve. Would love to get some feedback and see where it can go!
MIT licensed.
Repo: https://github.com/mystralengine/mystralnative
Docs: https://mystralengine.github.io/mystralnative/

value: Show HN: Mystral Native – Run JavaScript games natively with WebGPU (no browser)


value: tonyspiro

value:
Hi, I'm Tony, founder of Cosmic (AI-powered headless CMS and application development platform). We kept running into the same problem: create a blog post with the help of an AI agent, use the output for another prompt to create social posts, then manually post to X, LinkedIn, Facebook. Every single time.
So we built AI Workflows — chain multiple agents together and let them run autonomously, with each step receiving outputs from previous steps.
Three agent types you can chain:
- Code Agents: Build features in GitHub with commits and pull requests.
- Content Agents: Generate CMS content with context injection from previous steps.
- Computer Use Agents: Automate browser workflows and record demos.
How it works:
1. Define steps with agent type, prompt, and configuration
2. Steps run sequentially or in parallel (configurable)
3. Context passes automatically between steps
4. Trigger manually, on a schedule (cron), or via CMS and API events (object.created, object.edited, etc.)
5. Add approval gates for human review before critical steps
Example: Autopilot feature development:
Step 1: Content Agent writes a feature spec based on user feedback
Step 2: Code Agent builds the feature, creates PR, and deploys to production
Step 3: Content Agent generates documentation and a changelog entry
Step 4: Computer Use Agent posts update to team Slack with the PR link and preview URL
Currently in beta. Would love feedback on the workflow model and what use cases you'd want to automate.

value: Show HN: Cosmic AI Workflows – Chain AI agents to automate multi-step projects

author: tonyspiro


value: xnan

value: Show HN: EduFSDP – Minimal and educational Fully Sharded Data Parallel

author: xnan


value: Serenacula

value: Show HN: splitby — a modern, regex capable alternative to cut

author: Serenacula


value: koryna

value:
I got tired of meditation apps with subscriptions and gamification, so I built a simple PWA that does one thing: track your total meditation time and show progress toward 10,000 hours.
Features:
Timer with gong (Android) / notifications (iOS workaround for PWA limitations)
Lifetime meditation tracking
Set initial hours if you've already been practicing
Screen dimmer (iOS requires screen on for timers)
No account, no tracking, data stays local
Free forever
Built as a PWA because I wanted it to work everywhere without app store fees.
The 10,000 hours concept isn't gamification - it's just showing "this is how much you've sat" without streaks or badges.

value: Show HN: Maditate – Meditation timer tracking your 10k hours to enlightenment

author: koryna


value: dstamp

value: Show HN: Decrypting the Zodiac Z32 triangulates a 100ft triangular crop mark

author: dstamp


value: ValtteriL

value: Show HN: Triangular Arbitrage Bot with Kernel Bypass

author: ValtteriL


value: PUXABRIGA

value:
Hi HN, I'm the developer.
I built a persistent 3D space inspired by the "Million Dollar Homepage", but multiplayer. The concept is a collective time capsule where every frame is permanently owned by a user.
Tech Stack:
Frontend: Three.js / React Three Fiber.
Backend: Firebase (Firestore + Cloud Functions).
Payments: Stripe (for claiming frames/auction).
It’s a social experiment without algorithmic curation. The community decides what the space looks like.
You can check it here: https://the-gallery-f51a8.web.app
Feedback on performance/loading times is appreciated!

value: Show HN: The Gallery – A collaborative 3D time capsule

author: PUXABRIGA


value: mmnb

value:
Today you can easily adopt AI coding tools because you have git for branching and rolling back if AI writes bad code. We haven't seen this same capability for data and decided to build it ourselves.
Nile is a new kind of data lake, purpose built for using with AI. It can act as your data engineer or data analyst creating new tables and rolling back bad changes in seconds. We support real versions for data, schema, and ETL.
We'd love your feedback on any part of what we are building - https://getnile.ai/
What do you think?

value: Show HN: We are building Git for data

author: mmnb

title: Show HN: We are building Git for data


value: miketu

value: Show HN: Manager List is now live

author: miketu

title: Show HN: Manager List is now live


value: runkids

value:
Hey HN,
With tools like Moltbot(https://clawd.bot/) gaining traction, I got thinking about AI agents executing shell commands with full permissions by default.
I built veto to add a safety layer:
1.Intercepts commands before execution
2.Risk-based authentication (Touch ID for critical, simple confirm for low)
3.Custom rules for project-specific patterns
4.Full audit trail
Currently supports Claude Code (via hooks). Looking into Moltbot integration but it doesn't expose hooks yet — if anyone has ideas, I'm all ears.
Feedback welcome.
https://github.com/runkids/veto

value: Show HN: Veto – Intercept dangerous commands before AI executes them

author: runkids


value: vag-mac-mini

value:
Hello HN,
I’m sharing a personal project I’ve been working on: a modular, "headless" operating system for my digital life, hosted locally on a Mac Mini M4.
The source code is available here:
https://github.com/vag-mac-mini/PAIOS_Public
I travel frequently and wanted a "sovereign" system that doesn't rely on SaaS subscriptions or cloud data. The stack is:
- Hardware: Headless Mac Mini M4 (16GB).
- AI Core: Qwen 3 VL 8B (Abliterated) running via MLX.
- Network: Tailscale (for remote access via PWA).
- Agentic Layer: Custom Python scripts for tool use (API calls, system control).
The constraint for this project was unique: I did not write the code manually. I utilized Google Gemini to architect and generate the Python files with Antigravity IDE, acting as the "product manager". The code structure is admittedly messy in places, but it is fully functional.
The OS currently runs 10 active modules, categorized by function:
-- Intelligence & Memory --
* Digital Diary: Uses Vision AI to analyze screen activity/productivity and logs daily summaries to Apple Notes.
* Voice & Memory: Indexes voice transcriptions into a searchable "Second Brain."
* Ghostwriter: Remixes rough voice notes into structured essays or book chapters.
-- Global Logistics --
* Travel Command: Aggregates flight/visa data and summarizes local security risks via Tavily API.Gives recommendations for packing based on country/city/period/weather.
* Aero Intel: Audits flight paths and generates deep links for travel logistics.
* Chronos Calendar: A master schedule that integrates financial timelines with travel itineraries.
-- Network & Security --
* Network Sentry: Monitors the local ARP table for unknown devices.
* Secure Dead Drop: An encrypted P2P file tunnel between my devices.
* CRM & Network: A relationship database that parses raw notes into structured contacts.
Latest update that is not on GitHub, created a python script and added it on cron where it uses an api to check all the bank holidays across the globe(excluding the major ones) checks my contacts, which could be from all over the world, see's who is from the country with the bank holiday and I receive an iMessage in the morning in order to wish them happy whatever holiday.
This is not a SaaS or a commercial product. I am open to feedback on the architecture or suggestions for other "sovereign" modules I could add.
Thanks.

value: Show HN: P.ai.os – A local, modular AI "operating" system for macOS (M4/MLX)

author: vag-mac-mini


value: soderpop

value: looking for feedback and users

value: Show HN: I built an easy to use P2P music streaming site

author: soderpop

story_text: looking for feedback and users


value: pablituuu

value:
I’m a frontend developer specialized in building complex web-based video and image editors.
This project is a production-grade video editor built with Next.js, WebGL and Fabric.js, designed to handle timelines, layers and real-time interactions directly in the browser.
Key aspects:
- Canvas-based editing with Fabric.js + WebGL
- Timeline-driven video composition
- AI-assisted workflow (Gemini) for content manipulation
- Built for performance and real-world usage
- Deployed on GCP
I’m sharing this to get feedback from the HN community and also to connect with startups or teams looking to build custom video or image editors on the web.
Happy to answer any technical questions.

value: Show HN: I build production web video and image editors (WebGL, Fabric.js, Next)

author: pablituuu


value: federicotdn

value: Hey HN, I developed this small script to preview how many files were being created by running `curl ... | bash` setup scripts, after recently setting up a new Fedora install. Maybe it'll be useful to someone here. Cheers !

value: Show HN: pcpb – preview effects of `curl – bash` scripts

author: federicotdn


value: absmugz

value:
built Sciro to solve the "silent struggle" in online learning.
Most EdTech is a black box—you don't know a student is stuck until they fail a quiz or quit. Sciro uses interaction signals (behavioral telemetry) to detect confusion and fatigue in real-time, allowing for instant AI or human intervention.
Tech: On-device inference engine using interaction event streams. No PII, no cameras, no microphones.
I'd love to hear your thoughts on the privacy-first approach and the data schema!

value: Show HN: Sciro – SDK to detect learner confusion without cameras or mics

author: absmugz


value: bhackett

value:
Hey HN, we're building a library of open source SaaS apps for small businesses and personal use.  You can browse the apps at https://builder.replay.io, these are free to copy or download and use however you want.  Examples:
* https://builder.replay.io/gallery/Sales%20CRM — Sales CRM with pipeline view and deal tracking
* https://builder.replay.io/gallery/Issue%20Tracker — Issue tracker with projects and triage view
* https://builder.replay.io/gallery/Team%20Wiki - Internal docs with nested pages and customizable tables
* https://builder.replay.io/gallery/Invoicerator — Time tracking + invoice generation for freelancers
* https://builder.replay.io/gallery/Accounterize - Accounting system for tracking financial transactions
* https://builder.replay.io/gallery/Inventory%20Tracker - Inventory management for production facilities
We love building bespoke software with AI, but many businesses have needs for similar tools and we want to strike a middle ground between having to build something from scratch or pay for expensive and immutable off the shelf software.
These apps have comprehensive, passing test suites and are a good place to start for a vibe coding project, but we're also building out the apps (and their test suites) into complete tools ready for immediate use. See more here: https://blog.replay.io/communal-saas-apps
If you're interested in using these you can sign up as an early adopter on any of the app landing pages, and we'll support you to make sure things are working great.

value: Show HN: 50+ open source AI-built SaaS apps

author: bhackett


value:
Hi HN,
We built Stac a server driven UI framework for Flutter.
The idea is simple: instead of shipping a new app release for every UI change, the app renders UI from JSON delivered by the backend. This allows teams to update layouts, experiment with flows, and roll out changes instantly while keeping Flutter’s performance and type safety.
Stac is open source and already used in production by startups and enterprise teams for things like:
Feature flags and experiments
Faster iteration on UI without app store delays
Sharing UI logic across multiple Flutter apps
We are currently working on better tooling, validation, and a hosted solution for managing and deploying UI schemas.
Would love feedback from people who have built or evaluated server driven UI systems. What tradeoffs or pitfalls should we be thinking more about?
Repo: https://github.com/StacDev/stac

value: Show HN: We ship Flutter app updates without resubmitting on AppStore


value: karamalaskar

value:
Hey HN,
I wanted to share a project I’ve been working on called Convoxa. It’s a native iOS transcriber/summarizer. I had two main goals: keep it efficient and keep it private.
THE TECH STACK
100% Swift & SwiftUI: No heavy cross-platform wrappers or bloated dependencies.
Binary Size: The final build is only 4.8 MB.
Transcription: Uses Apple's latest speech APIs for maximum privacy and efficiency.
THE CHALLENGE: BYPASSING THE 4K CONTEXT LIMIT
The biggest technical hurdle was working with Apple’s foundation models. The default context window is capped at 4096 tokens, which is practically useless for anything over a 10-minute meeting transcript.
I ended up building a recursive chunking method to "feed" the model long-form data without losing the global context of the conversation. I use a sliding window approach where each chunk's summary informs the next, ensuring the final output doesn't "hallucinate" at the seams where the chunks meet. It’s now stable enough for long-form audio while remaining entirely on-device for supported hardware.
PRIVACY & AI MODES
On-Device: (Apple Intelligence required) - Total local processing.
Cloud: With reasoning for intelligent insights (Zero Data Retention).
I’m currently in the pre-order phase (out on Feb 3rd) and would love to get some feedback from this community on the performance and the chunking logic.
App Store: https://apps.apple.com/us/app/convoxa-ai-meeting-minutes/id6...

value: Show HN: A 4.8MB native iOS voice notes app built with SwiftUI

author: karamalaskar


value: kariopaul

value:
DocEndorse is an AI-powered e-signature assistant that lets you prepare, send, track, and follow up on documents through natural language instead of forms and drag-and-drop editors.
You can tell it what you want (“Send this NDA to John for signature”), and it will:
 • Find the right document and contacts
 • Detect and place signing fields
 • Assign signer roles
 • Suggest titles and messages
 • Send requests via email, SMS, WhatsApp, or Microsoft Teams
 • Track status and automatically follow up with signers
It supports the full e-signature lifecycle: self-signing, sending requests, templates, reminders, resends, and real-time status updates. Follow-ups are generated automatically with tone and timing adjusted based on progress.
visit https://docendorse.com/esignature to learn more

value: Show HN: DocEndorse – An AI assistant that runs your e-sign workflow in chat

author: kariopaul


value:
Hi HN — I’ve been working on a small open-source experiment around runtime AI safety.
The idea is to treat AI risk not as a binary “safe/unsafe” state or post-hoc failure analysis, but as accumulated constraint strain over time — similar to how engineers think about mechanical stress.
The project defines a simple, model-agnostic signal (GV) and a lightweight runtime monitor (Sentinel) that classifies risk into bands (green/yellow/red) and suggests interventions (alert, throttle, human review).
This is an early MVP — intentionally minimal — meant to explore whether continuous, quantitative safety signals are useful before failures occur, especially for agents and LLM-based systems in production.
I’d really appreciate feedback, criticism, or pointers to prior art I should study.
Repo: https://github.com/willshacklett/gvai-safety-systems

value: Show HN: Runtime AI safety via a continuous "constraint strain" score


value:
Hey HN! We launched a thing today, and built a cool demo that I'm excited to share with the community.
This tool creates AI agents easily and can handle some really technically complex work. I whipped up this rocket scientist agent in our tool in 10 minutes. I asked a couple of aerospace engineer friends what they thought, and they found it useful for their real work, which is why I want to share it here.  Here's the demo https://demo.contextual.ai/ and an overview https://docs.contextual.ai/examples/rocket_science
Would love to see technical HN folks and their experience with our tool (and whether it would be useful in your work).  Happy to go deep on architecture, retrieval strategies, and lessons learned.

value: Show HN: Agent Composer – Create your own AI rocket scientist agent


value: traceml-ai

value: Show HN: Distributed Training Observability for PyTorch (TraceML)

author: traceml-ai


value: Show HN: Open-source Robotics – Curated projects with interactive 3D URDF viewer


value: indigodaddy

value:
Hi all, I used Opus 4.5 for 99.9% of this project. Take that as you will.
https://github.com/jgbrwn/vibebin
vibebin is an Incus/LXC-based platform for self-hosting persistent AI coding agent sandboxes with Caddy reverse proxy and direct SSH routing to containers (suitable for VS Code remote ssh). Create and host your vibe-coded apps on a single VPS/server.
If anyone wants to test or provide some feedback that would be great. Core functionality works but there's likely to be bugs.
My intent for the project was for the tinkerer/hobbyist or even not super technical person to put this on a VPS and start just doing their own thing/experimenting/tinkering/learning etc.
I had so much fun working on this project, completely reinvigorated by it tbh.
I am just a Linux sysadmin and not a programmer at all (~just~ smart enough to figure stuff out though:) ) and I have to say the excitement and energy that was brought into me working on this project was nothing like I've ever experienced before. It makes me so optimistic about this future that we are either embracing or fending off (depending on your mindset).
Thanks for taking a look!

value: Show HN: Vibebin – code and host inside LXC containers on your own VPS/server

author: indigodaddy


value: SvenSchnieders

value: Show HN: A PDF to ePub Converter that works

author: SvenSchnieders


value: ulazimo

value:
I built a web app to track ski resort visits. Think "been.coffee" but for skiing.

  Features:
  - 4,586 ski resorts with coordinates (scraped from skiresort.info, geocoded via Nominatim)
  - Interactive map (Leaflet + OpenStreetMap)
  - Visit logging with dates/notes
  - Stats dashboard

  Tech stack: React Native + Expo (web), Firebase Auth/Firestore, Zustand for state, deployed on Vercel.

  The most interesting part was building the resort database - wrote a Node.js scraper that pulled 6,130 resorts and geocoded ~75% of them successfully. Happy to share the scraping approach if anyone's interested.

  Feedback welcome!

value: Show HN: Been Ski – Track ski resort visits across 4,500 resorts worldwide

author: ulazimo


value:
Founder here. I built NEO, an AI agent designed specifically for AI and ML engineering workflows, after repeatedly hitting the same wall with existing tools: they work for short, linear tasks, but fall apart once workflows become long-running, stateful, and feedback-driven.
In real ML work, you don’t just generate code and move on. You explore data, train models, evaluate results, adjust assumptions, rerun experiments, compare metrics, generate artifacts, and iterate; often over hours or days. Most modern coding agents already go beyond single prompts. They can plan steps, write files, run commands, and react to errors.
Where things still break down is when ML workflows become long-running and feedback-heavy. Training jobs, evaluations, retries, metric comparisons, and partial failures are still treated as ephemeral side effects rather than durable state. Once a workflow spans hours, multiple experiments, or iterative evaluation, you either babysit the agent or restart large parts of the process. Feedback exists, but it is not something the system can reliably resume from.
NEO tries to model ML work the way it actually happens. It is an AI agent that executes end-to-end ML workflows, not just code generation. Work is broken into explicit execution steps with state, checkpoints, and intermediate results. Feedback from metrics, evaluations, or failures feeds directly into the next step instead of forcing a full restart. You can pause a run, inspect what happened, tweak assumptions, and resume from where it left off.
Here's an example as well for your reference: You might ask NEO to explore a dataset, train a few baseline models, compare their performance, and generate plots and a short report. NEO will load the data, run EDA, train models, evaluate them, notice if something underperforms or fails, adjust, and continue. If training takes an hour and one model crashes at 45 minutes, you do not start over. Neo inspects the failure, fixes it, and resumes.
Docs for the extension: https://docs.heyneo.so/#/vscode
Happy to answer questions about Neo.

value: Show HN: First autonomous ML and AI engineering Agent


value: Show HN: AXP – Sudo for AI Agents (Postgres Proxy with PII Masking)


value: DaveyLovesCode

value:
Cocoon uses Grok (via OpenRouter) to filter your X/Twitter feed in real-time.
You define interests (AI, design, startups, whatever) and blocks (rage bait, engagement farming, political outrage). The LLM reads each post and hides what doesn't match.
I built it because I was tired of X's algorithm pushing garbage (remember the Grok bikini nonsense a couple of weeks ago?) and wanted something that lets me define relevance, not an algorithm optimizing for engagement. It honestly works really well, and I've found the base X algorithm is improving over time due to me not getting sucked into the garbage posts.
Stack: Svelte 5, WXT, TypeScript. BYOK model—your API key stays encrypted locally.
Website: https://cocoon.surf
Chrome Link: https://chromewebstore.google.com/detail/cocoon/ohidacajglhk...
Would love feedback on the filtering accuracy and prompt tuning. PRs welcome if you want to contribute.

value: Show HN: I built an open-source X/Twitter filter that uses X's own AI against it

author: DaveyLovesCode


value: luxpir

value:
Hi HN,
In 2014 my idea of a futuristic translation tool was a souped up Vim plugin or an ncurses TUI app that would autocomplete typing and do hyper-fast translation memory lookups. A decade+ later and I moved out of full time translation and into dev work for translation/localisation agencies. Google developed the transformer model in their translation research, having already given us the neural network improvements from around 2016. Then workable coding agents surfaced and ideas continued to percolate. A few discussions with colleagues, who'd done similar pre-AI, and projects that failed to gain traction with clients later, I thought I should give it a go myself.
I knew exactly what I needed to build, what stack I wanted to use, had been testing LLM editing of machine translation (of NN type) in an elaborate script with batching and RAG and error handling and so on. But models and "harnesses" have kept improving, the features I thought would be months of work were a week (a video dubbing and subbing suite, with cloned voices, time alignment etc.). Performance and security audits from multiple models tightened things up. Continue to do so. Django takes care of secure basics, I work on bugs and performance everywhere else.
I have now a next gen translation tool. It can do really useful things that the existing SOTA CAT tools cannot (yet) do due to inertia and massive corp culture.
I've got 100s of tasks still to do (todoist mcp ftw) and doubtless many more bugs to iron out. But I'm slowing down on features now and switching to marketing, distribution, talking to audiences etc. so I can concentrate on delivering value.
Keen to hear thoughts. Homepage for the "Studio" is here: https://studio.languageops.com and if you're not interested in the tool, come and spin a 3D globe which says hello in every language of the world as you hover over it: https://languageops.com. Easter egg somewhere south.

value: Show HN: I could build the translation tool I've wanted for 10 years

author: luxpir


value: Show HN: A userscript to filter out LLM/AI content from HN


value: seanlf

value:
42 validation errors in one run. Claude apologising instead of writing HTML. OAuth tokens expiring mid-digest.
Then I fixed the constraints. Eight days, zero failures, zero intervention.
The secret wasn't better prompts... it was treating the LLM as a constrained function: schema-validated tool calls that reject malformed output and force retries, two-pass architecture separating editorial
judgment from formatting, and boring DevOps (retry logic, rate limiting, structured logging).
The Claude invocation is ~30 lines in a 2000-line system. Most of the work is everything around it.
https://seanfloyd.dev/blog/llm-reliability
https://github.com/SeanLF/claude-rss-news-digest

value: Show HN: I Stopped Hoping My LLM Would Cooperate

author: seanlf


value: blackknightdev

value:
Hey HN,
I built SaecretHeaven because I was frustrated that every cloud photo service can see my images. Google scans for content, Apple has master keys, and most services store unencrypted.
SaecretHeaven is different:
• *True zero-knowledge*: Photos are encrypted client-side with XSalsa20-Poly1305 before upload. The server only sees encrypted blobs.
• *Decentralized storage*: Encrypted files go to IPFS with Pinata pinning across multiple EU nodes. No single point of failure.
• *Key anchoring*: Your 12-word recovery phrase derives your encryption key via Argon2id. We never see it.
• *Works offline*: Full PWA with local-first architecture. Desktop apps via Tauri.
Tech: Next.js 14, Better Auth, Supabase (metadata only), IPFS/Pinata
The beta opens Feb 3rd with 30 spots. Would love feedback from the HN community on the security model.
Site: https://saecretheaven.com
Happy to answer any questions about the architecture!

value: Show HN: SaecretHeaven – Zero-knowledge encrypted photo vault with IPFS backup

author: blackknightdev


value: A small JavaScript/TypeScript library for fetching YouTube transcripts without OAuth. Useful for indexing, summarization, and AI experiments. Feedback welcome.

value: Show HN: YouTube Transcript API in JavaScript (NPM package)


value: EternalAlgrthm

value: Show HN: MikeBrain – Governance framework for AI agents

author: EternalAlgrthm


value: psoto

value:
We adapted RALPH for ML workflows.
It runs experiments autonomously, forming hypotheses, training models, evaluating results, iterating on evidence.
W&B integration for long-running jobs. Full audit trail.
Tested on Kaggle Higgs Boson, hit top 30 in a few hours.
Still early, lots to improve. Would love feedback.
github.com/pentoai/ml-ralph

value: Show HN: ML-Ralph – An autonomous agent loop for ML experimentation

author: psoto


value: alecf

value:
I grew up on the Infocom games and when microsoft actually open-sourced Zork 1/2/3 I really wanted to figure out how to use LLMs to let you type whatever you want, I always found the amount language that the games "understood" to be so limiting - even if it was pretty state of the art at the time.
So I figured out how to wrap it with Tambo.. (and run the game engine in the browser) basically whatever you type gets "translated" into zork-speak and passed to the game - and then the LLM takes the game's output and optionally adds flavor. (the little ">_" button at the top exposes the actual game input)
What was a big surprise to me is multi-turn instructions - you can ask it to "Explore all the rooms in the house until you can't find any more" and it will plug away at the game for 10+ "turns" at a time... like Claude Code for Zork or something

value: Show HN: I wrapped the Zorks with an LLM

author: alecf


value:
It all started with me wanting to measure my HRV and I tried many different apps but wasn't really impressed, either they came with an expensive subscription or they had a very cluttered interface, and the PPG (photoplethysmography (using the camera)) wasn't that accurate IMHO. A wearable like a smartring or a wristwatch would probably been better but I didn't wanna buy one...
So I started to build my own and it has been an interesting experience, I have been reading a lot about HRV, RR intervals and how to use the baevsky method for figuring out a stress index, fascinating reading.
Drift helps you understand your current capacity by looking at BPM, HRV, SI and amount of sleep per night. Without a wearable one have to manually start tracking sleep but it has a smart feature and will stop tracking after first unlock in the morning (it waits 2 hours for late night scrollers to make sure you're sleeping)
I didn't find any good open source apps for this so hopefully Drift gets some traction for the ones interested.
I'm a strong believer in OSS and I think users will like the openness of being able to see what's going on, and the convenience of getting it at the Play Store for a low price (no subscriptions or hidden fees).
GitHub (MIT open source): https://github.com/cladam/drift
Play Store: https://play.google.com/store/apps/details?id=com.ilseon.dri...
Thanks for checking it out.

value: Show HN: Drift, an open source HRV reader


value: hnthrowawaste

value: Show HN: Video feed experiment no login

author: hnthrowawaste

title: Show HN: Video feed experiment no login


value: jucasoliveira

value: Show HN: Script: JavaScript That Runs Like Rust

author: jucasoliveira


value:
I've been using Claude Code on the web a lot, often running multiple sessions on different branches at the same time. The problem is there's no easy way to know when a branch has been updated or what changed - you end up tab-hopping between GitHub and your terminal trying to keep track of everything.
So I built Git Watchtower - a terminal UI that polls your remote and gives you live updates when any branch gets new commits. When something changes you get a visual flash + optional audio notification, can preview the diff, and switch to that branch with a single keypress. It auto-pulls your current branch too, so you're always looking at the latest code.
What it does:
- Monitors your remote for new commits, new branches, and deletions
- Visual + audio notifications when updates arrive
- Preview commits and changed files before switching
- Auto-pull when your current branch is updated
- Activity sparklines showing 7-day commit history per branch
- Optional built-in dev server (static or custom command like next dev) that restarts on branch switch

value: Show HN: Git-Watchtower – Quickly Manage 5 plus Claude Code on the Web Threads


value: yuuuzeee

value: Built this small tool to control my Mac with an Xbox controller. It runs in the menu bar and maps buttons to mouse, keyboard, and common shortcuts.<p>Useful for when you want to browse from the couch or just prefer a gamepad for casual navigation. Nothing fancy – just Swift + IOKit HID.

value: Show HN: Control macOS with an Xbox Controller

author: yuuuzeee


value: ahampt

value:
I built an iOS app that runs Qwen3-TTS-12Hz-0.6B locally on your phone. No server calls, no data leaves your phone.
You can record a voice, generate speech, export audio files, and share custom voices. The model is quantized to 8-bit to run on iPhone. One-time purchase for export/import features when it launches, but generation will remain unlimited when launched. No subscription.
Beta: https://testflight.apple.com/join/98d1hB6U
Happy to answer any questions!

value: Show HN: Duperr – On-device voice cloning using Qwen3-TTS for iOS

author: ahampt


value: Show HN: ACME Proxy using step-ca

title: Show HN: ACME Proxy using step-ca


value: Show HN: Syntux – JSON-to-UI for Websites


value: SamuelBennettAI

value: Show HN: AI Contract Review for SMBs (Flags Hidden Liabilities)

author: SamuelBennettAI


value: Show HN: See-SURF – Security tool (now AI powered) to find vulnerable SSRF param


value: vladris

value: I vibe coded this for myself but figured it's worth sharing. I have a blog post that covers some of the technical aspects here: https://vladris.com/blog/2026/01/27/jazz-an-exploration.html

value: Show HN: An interactive jazz study guide

author: vladris


value: samueldurante

value: Show HN: A simple, transaction-safe SQL migration tool

author: samueldurante


value: Speykey

value: Show HN: Time-Shards – hash-verifiable evidence packs from milestone logs

author: Speykey


value: oding

value: Show HN: Using machine learning to detect steganography

author: oding


value: devmukherjee

value: Show HN: Gallagher Security Python SDK and Tools

author: devmukherjee


value: Intragalactic

value: Show HN: Privacy-first app analytics for Swift and React Native

author: Intragalactic


value: arsentjev

value: Show HN: Pinecone Explorer – Desktop GUI for the Pinecone vector database

author: arsentjev


value: viraatdas

value: Show HN: Lendy – Keep track of books you have lended

author: viraatdas


value: Show HN: Chrome extension to keep Trello columns always visible across tabs


value:
I developed a simple AI-based tool for compressing videos. You upload a video, which can reduce the file size while maintaining quality and optimizing your video. It supports formats such as MP4, MOV, AVI, etc., compressing file size without losing picture quality.
All programs run in the browser.
I mainly want to hear feedback on output quality, user experience, and any technical improvements worth exploring.

value: Show HN: A free online video compression tool for instant compression


value: Show HN: How would you decide famous SCOTUS cases?


value: hnthrowawaste

value: Show HN: Infinijest, video scrolling experiment no login


value:
Built two things:
Predictor Agent - Scrapes top Polymarket traders, finds their consensus bets, scores entry quality. Currently tracking 51 real signals.
AgentWallet - The "financial leash" I built so the agent can't go rogue. Spend limits, approval thresholds, time windows, full audit trail.
Live demos:
Predictor signals: https://predictor-dashboard.vercel.app
AgentWallet: https://agentwallet-dashboard.vercel.app
The idea: AI agents will need to spend money. Someone needs to build the guardrails. That's AgentWallet.
GitHub: https://github.com/JackD720/agentwallet

value: Show HN: My AI tracks Polymarket whales with guardrails so it won't bankrupt me


value:
I built Minima LMS after working with several LMS platforms and wanting to implement some design ideas differently.
Key decisions I made:
- Bitmap-based view tracking - tracks actual viewing/skipping patterns, not just "completed/incomplete"
- Reusable date-based content - courses with specific dates can be duplicated without manually updating every date reference
- Granular nested permissions - fine-grained access control that works naturally with hierarchical content structure
- Caption-powered search - search video transcripts and jump directly to the timestamp
- Live session attendance that handles all edge cases (entry/exit/re-entry) without needing server-side exception handling
These choices solved real pain points I experienced. For example, most LMS platforms either over-track (too much DB overhead) or under-track (just yes/no completion). The bitmap approach gives detailed analytics efficiently.
Built with Django, SolidJS, PostgreSQL, OpenSearch. MIT licensed.
Quick start: sh dev.sh up
Would love feedback from the community!

value: Show HN: Minima LMS – Bitmap view tracking, caption search, reusable content


value: Shaehenderson

value:
With AI agents getting more autonomous, controlling irreversible actions (sending money, emails, deploying code) is becoming critical.
Nyxi introduces execution-time governance: a clean veto/allow boundary that works regardless of whether proposals come from humans or models.
Public docs and demos here (proprietary, no source): https://github.com/indyh91/Nyxi-Showcase
Main overview: https://github.com/indyh91/Nyxi-Showcase/blob/main/docs/PROD...
Would love feedback on the concept!

value: Show HN: Nyxi – Execution-time governance for irreversible

author: Shaehenderson


value: wlswo

value:
I built Xray because I was frustrated with existing screenshot tools that were either too bloated, required accounts, or didn't play well with multiple monitors and high-DPI scaling.
Xray is a lightweight, open-source screenshot utility built with Rust and Tauri. The goal was to create a tool that stays out of the way but provides precise control when needed.
Key Technical Specs:
Core: Built with Rust to ensure memory safety and low overhead.
Frontend: Minimalist UI using Tauri (React/TS), keeping the binary size significantly smaller than Electron-based alternatives.
Performance: Optimized for quick startup and low latency during capture.
Why I built it:
Most tools focus on social sharing or cloud storage. I wanted something that focused on the local workflow: capture, annotate (arrows, text, blur), and copy-to-clipboard or save. I also wanted to ensure it handles complex display setups without the common "offset" bugs found in many cross-platform screenshot libraries.
What’s different:
Native Feel: It uses system-native APIs via Tauri’s backend.
Privacy: No telemetry, no cloud sync, no accounts. Everything stays on your machine.
Clean Codebase: The project is structured to be easily extendable for those who want to add custom post-processing scripts.
The project is still in its early stages. I'm looking for feedback on:
Performance on various Linux window managers (Wayland vs X11).
UX/UI improvements for the annotation toolset.
Any features that are missing for a developer-centric workflow.
Github: https://github.com/wlswo/xray
I'll be around to answer any questions about the implementation or the tech stack.

value: Show HN: Xray – A minimal screenshot tool for developers (Rust/Tauri)

author: wlswo


value: starwisher

value: Show HN: Next.js and Spring Boot SaaS Starter (OAuth, Stripe, Admin)

author: starwisher


value: destroyerxyz

value:
Hey HN,
I've been working on ModifyWithAI, a framework that lets you embed an AI agent into your app so users can complete multi-step tasks through chat.
The idea: instead of users clicking through multiple screens, they describe what they want and the agent handles the workflow—while still giving them control to approve/modify actions.
v2 focuses on latency (targeting sub-500ms responses) and better user control over what the agent can do.
Would love feedback on the approach, especially from anyone who's tried adding agentic features to existing products.

value: Show HN: ModifyWithAI v2 – Add chat-based agents to your app

author: destroyerxyz


value: danieljhkim

value: Show HN: Local Agent – Local AI agent (Nova) with evolving memory

author: danieljhkim


value:
Hi HN, I’m Ryan, a student and solo dev.
I built PushPilot because I was tired of the "context-switching tax". Whenever a client or PM finds a UI bug—like a misaligned button or the wrong hex code—they usually send a screenshot. I have to stop my deep work, find the file in my repo, fix the CSS, and open a PR. It’s a lot of friction for such a small change.
What it actually does: It bridges the gap between the browser and your source code. You click the element on the live site, tweak it in a mini-inspector, and PushPilot opens a Pull Request in your GitHub repo with the code fix already written.
About the Safety & Permissions: I know giving a new tool GitHub access is a big ask. I've focused on keeping it as safe as possible:
Scoped Permissions: It only asks for access to the specific repos you choose.
No Auto-Merge: It only opens a PR. It never touches your main branch directly. You still have to review and hit "Merge" yourself.
Transparent Code: The PR shows you exactly what lines were changed so there are no surprises.
Why it’s cheap right now: I literally just put this live, and I want it to be a tool that freelancers can just "grab and go". I’m charging $9/mo for the solo plan because I’d rather have 100 people using it and giving me feedback than 5 big companies paying more. Since my run costs are extremely low, I don't feel the need to charge a premium while I'm still learning.
It currently works best with React and Tailwind, as that's my own stack. I’d love for you to try it out and tell me if the workflow makes sense or if I’m over-engineering a simple problem.
Why it’s cheap right now: Honestly, I just deployed this, and I want it to be something that a freelancer can just "grab and go." I’m charging $9/mo for the solo plan because I'd rather have 100 users using it and giving me feedback than 5 large companies using it and paying more. My run costs are super low, so I don’t need to charge a premium while I’m still learning.
It’s also optimized for React and Tailwind, just because those are what I’m using. I’d love for you to give it a shot and let me know if it makes sense or if I’m over-engineering something super simple.

value: Show HN: I built a tool that turns browser clicks into GitHub PRs for CSS fixes


value: reidjs

value: Show HN: WordRE, Wordle for Real Estate

author: reidjs

title: Show HN: WordRE, Wordle for Real Estate


value: margox

value:
I’ve been working on a side project for a while and wanted to share it with the HN community to get feedback.
The idea started simple: I wanted to do batch image processing entirely in the browser without uploading anything to a server. Most existing tools were either cloud-based (privacy concerns, slow for large batches) or desktop apps that were hard to automate and combine into workflows.
A big source of inspiration was macOS Automator. I really liked how you could chain small actions into repeatable workflows, and I wanted something similar for image processing on the web.
At first it was just basic operations like crop, resize, compress, and format conversion. Then I kept adding things like:
face mosaic
face-centered cropping
background removal
old photo restoration
Somewhere along the way it became a full pipeline system that can either run individual steps or chain multiple steps automatically.
Everything runs locally in the browser—no server-side processing, no uploads, no data tracking.
Technical notes (where I’m unsure)
CPU-heavy operations run in WebAssembly
Some steps are GPU-accelerated via WebGL
Most processing happens off the main thread with OffscreenCanvas + Web Workers
A few ML-ish tasks use transformer.js in the browser
Next.js is mostly just a UI shell, deployed on Vercel
It works, but I’m not sure this is the “right” architecture long-term. Some issues I’ve run into:
Memory usage grows fast when chaining multiple steps over large batches
Cleaning up intermediate buffers feels fragile
Safari behaves very differently from Chromium-based browsers
Not sure if Next.js is overkill since everything critical is client-side
Questions for HN
If anyone here has built heavy client-side tools, I’d love your thoughts on:
How to structure long-running pipelines without memory leaks
Patterns for cancellation / progress reporting without spaghetti code
Whether keeping everything browser-only makes sense
Any obvious architectural smells I’m missing
I’ve made it a usable tool mainly to test it with real workloads.
I’m still iterating, so brutally honest feedback is very welcome.

value: Show HN: A browser-only image processing pipeline inspired by macOS Automator

author: margox


value: volkanvardar

value:
My wife recently re-entered the job market and we noticed a frustrating trend: many of the roles are shared as regular status updates by recruiters rather than official listings in the Jobs tab.
I don't know why this became a practice, but they are very easy to miss, unlike the job listings with alerts and all kinds of search.
So I built this Chrome extension over a weekend to solve that problem. It tracks specific people or companies and captures those hidden opportunities from the feed.
## Technical / Privacy approach:
- Privacy-First: No data leaves the browser. Everything is stored locally.
- No Monetization: It’s free. I don’t believe in charging people who are currently out of work. No ads, no data selling.
- Classification: It uses simple keyword matching or optional AI classification.
- AI Implementation: If you want to use the AI features, you provide your own OpenAI API key. It's stored with local encryption and I’ve optimized the prompts so it usually costs less than $0.01 per day using gpt-3.5-turbo.
I'm looking for feedback on any features that would make the job hunt more manageable, in this brutal market conditions.

value: Show HN: LinkedIn Mate – Find job opportunities hidden in the feed

author: volkanvardar


value: oliverchoy

value:
Hi HN, I'm Oliver. I've been in the software and cloud engineering industry for a long time (28 years), and this past year genuinely changed how I think about coding.
The bottleneck isn’t syntax anymore. It’s clarity. I now spend more time describing what I want, testing results, and refining instructions than writing code line by line.
The spark for this project came from a presentation I gave at my son’s school in December, 2025. I expected mild interest. Instead, kids were completely engaged — hands up, pitching game ideas, iterating in real time.
That made me question something I’d always taken for granted: maybe the first skill kids need in an AI-first world isn’t coding. Maybe it’s learning how to instruct AI, evaluate output, and iterate responsibly.
Pixel Arcade Studio is a browser-based game studio where kids create real, playable games by giving instructions to an AI assistant. No coding, no installs, no open social features. Games are private by default and parents control visibility.
This is a side project I built nights and weekends. I’m here for honest feedback:
– What would you question or distrust about this approach?
– If you’re a parent, what would you need to see to feel comfortable with it?

value: Show HN: Pixel Arcade Studio –kids make playable browser games by instructing AI

author: oliverchoy


value: sashimikun

value: Show HN: AsyncReview – When the File System Becomes the REPL

author: sashimikun


value: DigitalSea

value: I needed something for screenshots but with some of the same features that screenshotapi.net has and embarked on a journey to build something and open source it. It's pretty fully featured with support for proxies, removing ads, cookie banners, returning a webpage as a PDF, image and more. Might be some bugs and things I haven't tested lurking, but it seems to be working well and worked for my needs.

value: Show HN: Captura – free open source screenshot app and API

author: DigitalSea


value: lincyang

value:
Hey HN! I built a Pokemon type effectiveness calculator that focuses on speed and simplicity.

  The problem: Existing type charts are either complex 18×18 tables or buried in wikis. When you're in a battle and need to know "what's Fire/Flying weak to?", you want an instant answer.

  The solution: A static-generated Next.js site with:
  - 43 SEO-optimized pages (18 single types + 20 popular combos)
  - Default examples (Fire/Flying loads with results immediately)
  - Quick example buttons (one-click to try popular combinations)
  - Battle simulator with STAB calculations

  Tech stack: Next.js 14, TypeScript, Tailwind CSS, fully SSG for <1s load times.

  Live: https://www.typematchup.org
  Source: [if you want to open source it]

  Would love feedback on the UX and any features competitive players would find useful!

value: Show HN: Type Chart Calculator – Fast Pokemon type effectiveness lookup

author: lincyang


value: atmz

value:
The code itself is pretty trivial, but the Return of the CLI has been really interesting. With LLMs, being able to have commands for things is a giant leap in cost and performance, and they can create them in an hour or two within the Claude Pro token limit.
Every line of code here was written by Claude in an hour or so, and it's now integrated with my clawdbot setup.

value: Show HN: NYT Cooking CLI

author: atmz

title: Show HN: NYT Cooking CLI


value:
I built Lapse because most of my blogs died quietly, abandoned after a few months.
lapse.blog is a minimal blogging platform with one rule: if you don't post for 30 days, your blog is
  permanently deleted. No warnings, no recovery.
How it works:

  - No signup. Your unique passphrase grants access to your blog. Same passphrase = same blog. (If two people pick the same one, they'll control the same blog by design)
  - The longer you post consistently, the longer it lives. Borrowing from social-media streaks, but for writing. If they can encourage you to Snapchat someone, surely we can encourage ourselves to write.
  - Markdown only. No images, no embeds.
  - RSS and Atom feeds included.
  - Forget your passphrase? Blog gets deleted. Stop posting? Blog gets deleted.
  - No ads, no tracking.

The idea is that impermanence, hopefully, removes the pressure to be perfect, and the deadline offers an incentive to keep writing.

value: Show HN: A blog that deletes itself if you stop writing


value: thenextechtrade

value:
Hi HN, I’ve been working on a dedicated interface for Grok 3’s generative capabilities: grokimages.net. While the official X integration is great, I felt it lacked the flexibility power users need—specifically for professional prompt adherence and video extension.
Key Technical Highlights:
Grok 3 + Flux.1 Pro Logic: Optimized for hyper-realistic skin textures and complex prompt adherence.
10s Video Evolution: We’ve bridged the gap from 4s loops to 10s cinematic motion with better temporal consistency.
I’m particularly curious about how you find the video consistency compared to Kling or Luma. Looking for feedback on the latency and the "Pro Engine" output quality.
ONLINE: https://grokimages.net/

value: Show HN: Grok Images and 10s Video Generator

author: thenextechtrade


value:
    We're building GrindMal, a dev ecosystem based on one rule: Artifacts > Opinions.

    This is NOT for beginners. It's for developers who learn by grinding on broken, real projects. No tutorials. No hand-holding. PRs are the only help.

    The Vision: To become the definitive "arena" where the most resilient developers prove their skills through silent collaboration and shipped code. Imagine a future "Hall of Grind" and autonomous challenge engines. (Link to your vision doc or a brief README section.)

    We are Alpha-Ready and Need:

        Go-builders to help with the core platform (Next.js/TypeScript, GitHub API integration).

        Design thinkers who understand that in this system, UX is a set of constraints that prevent comfort.

        Open-source veterans who want to help design the "broken projects" and review protocols.

    If you're interested:

        Read the Core Philosophy to see if it resonates.

        Your first task is not to message me. It's to submit a PR to our onboarding repo fixing a deliberately broken markdown file or a simple bug in our alpha site code. This is the only way in.

    Repo: https://github.com/Grind-Mal (Make sure the onboarding repo has a clear "first-alpha-contributor" issue!)

    This is a filter. The grind starts now.

value: Show HN: GrindMal – A dev "arena" (Alpha Invite)


value:
Hi HN — I built Modelfy, a web tool that generates a 3D mesh + textures from a single image, then lets you download the result (e.g., GLB/OBJ).
It’s aimed at quickly prototyping assets for 3D, games, and product mockups. It works best on a single object with a clean background; complex scenes can produce messy geometry.
I’d love feedback on output quality, workflows you’d expect (retopo, PBR maps, scale/origin), and what would make this useful in a real pipeline.

value: Show HN: Modelfy – Turn a single image into a 3D model (GLB/OBJ)


value: machala

value: Show HN: Heroshot – Automate documentation screenshots with a visual picker

author: machala


value: jamescampbell

value: Show HN: Kaboink Humanize and Stay on Brand

author: jamescampbell


value: anagri

value:
Bodhi Chat is a demo chat app that connects to Bodhi App running locally on your machine. The connection to Bodhi App is completely secure and backed by OAuth 2.1 PKCE standards. We also have a built-in Exa web — so the LLM can search the web during conversations if required. The complete setup is completely secured by OAuth authentication/authorization, and no access is allowed unless user consents to it.
Links:
- Demo: https://bodhiapps.github.io/chat/
- Bodhi App repo: https://github.com/BodhiSearch/BodhiApp
- Developer waitlist: https://developer.getbodhi.app
If you want to build your own Bodhi-powered app, join the developer waitlist. We're working with early developers to refine the SDK.

value: Show HN: Bodhi App – Bring your own AI model to any web app

author: anagri


value: jemmyw

value:
Hi HN,
I've written the developer tool I've wanted for some time: a process manager and log multiplexer in one. I think of it as a combination of overmind and lnav, both great tools in and of themselves, but focussed on my needs as a developer.
I wrote more about it here: https://www.aha.io/engineering/articles/over-it-all
Hope someone else finds it useful too.

value: Show HN: Overitall, a Procfile runner like overmind with log multiplexing

author: jemmyw


value: diginova

value: Show HN: GitHub Timeline – Visualize Your Code Journey

author: diginova


value: adius

value:
I wanted to make LLMs easier and faster to use by not having to give the same verbose instructions over and over again.<p>Therefore, cai provides many high level commands for great usability:<p>- cai value capital of Australia
- cai image photo of a banana
- cai ocr page.png
- pbpaste | cai rewrite 'more professional'

value: Show HN: Cai – CLI tool for AI tasks (Rust)

author: adius


value: saivishwak

value:
Hi HN,
We’ve been working on an project called Liquidos — Odessey, and wanted to share an early research preview to get feedback from the community.
Odessey is a Rust-first agent orchestration runtime focused on local-first execution and privacy. It came out of frustration with cloud-heavy agent frameworks that are difficult to reason about, secure, or run reliably on the edge. We wanted something closer to a runtime layer for agents rather than just another workflow abstraction.
Under the hood, Odessey is built on top of our open-source Rust agent framework, AutoAgents, and explores ideas like composing and orchestrating agents locally, skill execution, plugins, and sandboxed runtimes. The long-term direction is toward what we loosely call an agentic operating system — though we’re still pressure-testing whether that framing actually makes sense.
This demo is intentionally limited. It’s a preview of direction rather than a feature-complete product, and we’re sharing it early to learn before open-sourcing the full platform.
We’d really appreciate thoughts on:
Whether you’d consider using something like this, and for what use cases
What would need to exist for real-world adoption
Whether the framing makes sense, or if it should be positioned differently
If you’re interested in agent orchestration, local-first AI tooling, Rust-based runtimes, or alternatives to cloud-centric LLM frameworks, we’d love to hear your perspective.
Open-source agent framework (Rust): https://github.com/liquidos-ai/AutoAgents
If this direction resonates, we’re also keeping a small waitlist at https://liquidos.ai to share updates as the platform evolves.
Happy to answer questions and take critiques.

value: Show HN: Early Research Preview of a Rust-Based Agentic OS Runtime [video]

author: saivishwak


value: yuppiepuppie

value:
I love seeing all the small games that people build and post to this site.
I don't want to forget any, so I have built a directory/arcade for the games here that I maintain.
Feel free to check it out, add your game if its missing and let me know what you think. Thanks!

value: Show HN: The HN Arcade

author: yuppiepuppie

title: Show HN: The HN Arcade


value: RightSize runs your prompt against candidate models (Kimi, GLM, Qwen, Gemma etc.) in parallel via OpenRouter. Then it uses a stronger model as a Judge to score accuracy against a baseline model.<p>Happy to answer questions.

value: Show HN: RightSize CLI, Find the cheapest LLM that works for your prompt


value:
LiquidFetch gives you a clean, visual overview of your Mac.
Unlike tools like neofetch or fastfetch, LiquidFetch presents your setup info in a graphical interface. It's a 100% native macOS app.
Cost: Free.
Download: https://www.apptorium.com/liquidfetch or on the App Store: https://apps.apple.com/us/app/liquidfetch/id6757637185?mt=12

value: Show HN: LiquidFetch – a graphical system fetch for macOS


value: michaloo

value:
Hey HN,
I'm a data analytics and tracking consultant by day. Built this for my own projects and decided to productize it.
I'm testing two things at the same time:

  - Business model: one-time payment in an industry that's naturally subscription-based
  - Technical architecture: automated DevOps on your infrastructure (think ServerPilot or Laravel Forge, but for serverless setup, so on ongoing maintenance)

Tech details:

  - Minimal tracking script, cookieless by default
  - First-party tracking from your subdomain out of the box
  - Web installer provisions everything using a one-time API token, I don't need ongoing access. Once this is installed it becomes part of the user's infra

Happy to hear feedback or answer questions about the architecture or the business model.

value: Show HN: Once Analytics – self-hosted, buy-once analytics on serverless

author: michaloo


value: eyeskiller

value:
Hey HN,
I’m Lubos, a solo founder based in Slovakia. I’m building GlitchWard because I got tired of seeing SMBs and agencies running "naked" servers.
Most small teams ignore server security not because they don't care, but because enterprise tools (Wiz, Datadog Security) are too expensive, and manual hardening (fail2ban, OS updates) eventually gets forgotten.
I wanted a tool that creates a "self-defending" server, capable of stopping attacks even when I'm asleep.
CURRENT STATUS: We officially launched yesterday. During our beta, we onboarded 20+ clients and the beacon is currently protecting 100+ servers. You can also check out our demo video and launch details on Product Hunt: https://www.producthunt.com/products/glitchward
We are currently supporting only Linux based operating systems (Debian, Ubuntu, RHEL...)
WHAT IT DOES: You install a lightweight beacon agent (Rust binary), and it provides:
Active Defense: It doesn't just watch; it acts. We recently caught and killed a reverse shell attack in under 10 seconds. Read the analysis here: https://glitchward.com/blog/anatomy-of-an-attack-how-we-caug...
Important: All automated interventions are strictly regulated. The agent relies on multi-stage heuristic analysis and only executes active countermeasures when there is 100% certainty, ensuring it never interferes with legitimate workloads.
AI-Assisted Triage: Instead of cryptic logs, you get an instant analysis of what happened, why it matters, and how to fix it.
CIS Benchmarks & CVE Scanning: Automated hardening checks against industry standards and vulnerability monitoring for OS/NPM/Composer packages.
THE TECH STACK & "WHO BUILT THIS": I have 15+ years of experience architecting massive e-commerce projects from scratch (My LinkedIn: https://www.linkedin.com/in/eyeskiller/).
The Core: The Rust beacon and backend logic are 100% human-written by me, prioritizing stability and resource efficiency.
The UI: Full disclosure—I'm a tragic web designer, so the frontend (Vue.js + Tailwind) was built with heavy AI assistance.
Compliance: We are fully GDPR compliant and our security architecture is aligned with NIST CSF 2.0.
The platform is live at https://glitchward.com
LOOKING FOR FEEDBACK: I’m curious about your stance on Automated Response. Are you comfortable letting an agent kill processes automatically (given our strict confidence thresholds), or do you strictly prefer "alert-only" for production servers? (Note: GlitchWard supports both modes, so you can choose what fits your risk appetite).
If you want to try it out, I’ve created a coupon code HACKERNEWS for an 7-day trial - no credit card required (or just ping me at lubos@glitchward.com).
Thanks!

value: Show HN: GlitchWard – Active defense and CIS hardening for neglected SMB servers

author: eyeskiller


value: markoa

value:
Hey HN! We're Marko and Darko, building SuperPlane with a small team. SuperPlane is an open source DevOps control plane for running event-driven workflows. It works across the tools teams already use like Git, CI/CD, incident response, observability, infra, notifications, etc.
You can think of SuperPlane as 'n8n/Zapier for DevOps'.
How do we do DevOps today? For many teams it's a mix of brittle scripts, one-off CI jobs, bespoke GitOps, and manual approvals scattered across channels.
Pipelines are often the only workflow engine available, but they’re not a great fit when a workflow needs to span multiple repos/tools, wait for humans, or run over hours and days. Previously we built a CI/CD company Semaphore so we've seen it first-hand.
SuperPlane gives you a place to model these workflows as a system: connect your tools, define how events flow, and get a complete, queryable execution history for debugging, audit, and shared understanding.
Examples of what you can do with SuperPlane today:
- Cross-tool automation with guardrails: coordinate releases with approvals, time windows, checks, and rollback paths.
- Human-in-the-loop operations: pause for sign-off, collect decisions, and resume where you left off.
- Incident and on-call workflows: pull context from multiple systems, fan out notifications, and keep a work log.
- Glue work you don't want to re-build: webhooks, retries, routing, payload transforms, and a unified run history.
See pre-built examples in the docs: https://docs.superplane.com/get-started/example-use-cases/
Project status:
- Self-hosted only right now, alpha release. Apache 2.
- Integrates with GitHub, OpenAI, Dash0, PagerDuty, Slack, Cloudflare, Semaphore, AWS Lambda, SMTP, webhooks. Much more planned.
Links:
- GitHub repo: https://github.com/superplanehq/superplane
- Docs: https://docs.superplane.com
Curious to hear your take, especially:
1. What's the first DevOps workflow you’d want to encode?
2. Which missing integrations matter most to you (eg GitLab, Rootly, Kubernetes, Datadog, Terraform, etc)?
We’ll be in the comments. Thanks for reading!

value: Show HN: SuperPlane - open source DevOps control plane

author: markoa


value: alejandromav

value:
I built Quantarded, a side project that turns two noisy public data sources into conservative weekly stock signals.
For Reddit (r/wallstreetbets), it uses OpenAI strictly as a semantic parser to extract tickers and buy/sell/neutral intent from text, then applies a mechanical weekly scoring model (recency decay, attention share, buy/sell imbalance). No fundamentals, no price features, no user weighting.
For U.S. House trade disclosures, it uses a separate, slower model focused on credibility and position building rather than timing.
It’s intentionally not a trading bot or a prediction engine. I publish weekly snapshots and performance publicly, including weeks where signals are weak or inconclusive.
Would love feedback, especially on failure modes or things you’d want to see to trust (or falsify) a system like this.

value: Show HN: Quantarded, extracting WSB stock signals using OpenAI

author: alejandromav