value:
Hi HN,
TL;DR: POST JSON to an HTTP endpoint. Get Parquet and compressed segments in your S3 bucket. No Kafka, no Kinesis, no glue code.
EdgeMQ ingests newline delimited JSON from one or more global endpoints (dedicated vm's). Data is delivered to your S3 with commit markers in one or more formats of your choosing:
* Compressed WAL segments (.wal.zst) for replay i.e. raw bronze
* Raw/opaque Parquet (keeps the original payload in a payload column + ingest metadata).
* Schema-aware Parquet - materialized views defined in YAML
Feedback request:
The platform is now open for public beta (there are a number of current live users) and I am keen to collect further feedback and explore use cases.
I would be grateful for comments and thoughts on:
* Use cases - are there specific ingest use cases that you use regularly?
* Ingest formats - the platform supports NDJSON - do you use others?
* output formats - are there other transformations outside of the 3 supported that would be useful?
* Output locations - S3 is supported today, but are there other storage locations that would simplify your workflows? Object store has been the target to date.

value: Show HN: Edge HTTP to S3, now with schema-aware Parquet


value: sberens

value:
There's been a lot of discussion around the california budget and some proposed tax policies, so I asked claude code to research the budget and turn it into an interactive dashboard.
Using async subagents claude was able to research ~a dozen budget line items at once across multiple years, adding lots of helpful context and graphs to someone like me who was starting with little familiarity.
It still struggles with frontend changes, but for research this probably 20-40x's my throughput.
Let me know any additional data or visualizations that would be interesting to add!

value: Show HN: Interactive California Budget (By Claude Code)

author: sberens


value: letsfancy

value: Hi HN!  I’m back with my 2nd app, still built with @FlutterFlow, and powered by Gemini (switching it up from ChatGPT this time!). The inspiration was simple: I love the emotional depth of Inside Out and the addictive, clear progress of Duolingo’svertical roadmap. I wanted to merge them into something that makes self-reflection feel like a journey rather than a chore. Introducing: Letsfancy Joy  Vertical Roadmap: Log and review your emotional history on a single, continuous path—not another calendar of faces. The Emotion Pill: Each emotion has a "Pill" with varying intensity. As we say: "The deeper the feeling, the longer the memory." Core Memories & Beliefs: When an emotion reaches "Core-level" intensity, link it to a Belief (like Kindness or Curiosity) to strengthen your self-awareness.  Vivid Logs: Add images and "trigger contexts" to turn a simple log into a vivid Core Memory.  I’d love to hear your thoughts on this approach. Thank you!

value: Show HN: Joy – What if mood tracking felt like Inside Out meets Duolingo?

author: letsfancy


value:
I review PRs all day and I've basically stopped reading them. Someone opens a 2000-line PR, I scroll, see it's mostly AI-generated React components, leave a comment, merge. I felt bad about it until I realized everyone on my team does the same thing.
The problem is diffs are the wrong format. A PR might change how three buttons behave. Staring at green and red lines to understand that is crazy.
The core reason we built this is that we feel that products today are built with assumptions from the past. 100x code with the same review systems means 100x human attention. Human attention cannot scale to fit that need, so we built something different. Humans are provably more engaged with video content than text.
So we RL trained and built an agent that watches your preview deployment when you open a PR, clicks around the stuff that changed, and posts a video in the PR itself.
Hardest part was figuring out where changed code actually lives in the running app. A diff could say Button.tsx line 47 changed, but that doesn't tell you how to find that button. We walk React's Fiber tree where each node maps back to source files, so we can trace changes to bounding boxes for the DOM elements. We then reward the model for showing and interacting within it.
This obviously only works with React so we have to get more clever when generalizing to all languages.
We trained an RL agent to interact with those components. Simple reward: points for getting modified stuff into viewport, double for clicking/typing. About 30% of what it does is weird, partial form submits, hitting escape mid-modal, because real users do that stuff and polite AI models won't test it on their own.
This catches things unit tests miss completely: z-index bugs where something renders but you can't click it, scroll containers that trap you, handlers that fail silently.
What's janky right now: feature flags, storing different user states, and anything that requires context not provided.
Free to try: https://morphllm.com/dashboard/integrations/github
Demo: https://www.youtube.com/watch?v=Tc66RMA0nCY

value: Show HN: Morph – Videos of AI testing your PR, embedded in GitHub


value: zotimer

value: Show HN: Job Tracker, Local-first job search app powered by Claude Code

author: zotimer


value: xxmrlnxx

value:
I built TITO because threat modeling is broken. It either requires drawing diagrams by hand, hiring consultants, or buying tools that start at $50K/year. Most teams skip it entirely.
TITO reads your code and builds the threat model for you:

    go install github.com/Leathal1/TITO/v2/cmd/tito@latest
    tito scan --repo .

What you get in ~60 seconds:
- STRIDE-LM classification — threats categorized by Spoofing, Tampering, Info Disclosure, DoS, Elevation of Privilege, Lateral Movement
- MITRE ATT&CK mapping — every finding linked to real-world attack techniques
- Attack path analysis — how individual findings chain into realistic breach scenarios (think BloodHound for app-layer threats)
- MAESTRO analysis — maps threats across agentic AI security layers (if your code uses LLMs/agents)
- Compliance mapping — PCI DSS v4.0, SOC 2, ISO 27001, NIST 800-53, HIPAA
- Interactive 3D visualization — explorable data flow diagrams with attack path overlays
- PR threat diffing — catch security regressions on every pull request
Under the hood it runs Semgrep for static analysis, detects your architecture (monolith, microservices, serverless, AI/ML), and layers threat intelligence on top.
Single binary. No config files. No accounts. No data leaves your machine.
The Cloud Security Alliance is listing TITO as a community implementation of their MAESTRO framework for agentic AI security.
CI/CD integration:

    - uses: Leathal1/TITO@v2
      with:
        maestro: true
        fail-on: critical

Technical details: written in Go, ~15K LOC, MIT licensed. GitHub Action on the Marketplace. Docker images available.
I'd love feedback — especially from folks doing AppSec or building AI agents. What frameworks or compliance mappings would be most useful to add?
GitHub: https://github.com/Leathal1/TITO

value: Show HN: TITO – Automated threat modeling from code (open source)

author: xxmrlnxx


value: haqaliz

value:
Hey HN! I'm the maker of Rereflect.
I built this after watching teams (including my own) drown in scattered customer feedback across emails, Slack, support tickets, and surveys. Valuable insights kept getting lost.
What it does:
• Analyzes sentiment automatically
• Categorizes pain points (bugs, UX issues, pricing concerns, etc.)
• Extracts feature requests
• Flags churn risk
• All from one dashboard
Tech stack: FastAPI + PostgreSQL backend, Next.js frontend, custom AI analysis engine.
Free plan: 250 feedback items/month. Just upload a CSV to get started.
I'd love feedback from the HN community:
- What would make this more valuable?
- What integrations matter most? (Slack, email forwarding, webhooks?)
- How do you currently handle feedback?
Happy to answer any questions!
Try it: https://app.rereflect.ca

value: Show HN: Rereflect – AI-powered customer feedback analysis

author: haqaliz


value: hleszek

value: I made a llama.cpp Notebook PR to add a Notebook page to the official llama.cpp webui.<p>Now I don't need text-generation-webui to have the Notebook functionality, and can always use the latest llama.cpp features without waiting for an update of the llama.cpp python bindings.

value: Show HN: Notebook page on llama.cpp official webui

author: hleszek


value: solarsyn

value:
Hey HN! I'm Aaron, the creator.
I built this because I was frustrated with manually calculating coordinates
for e-paper displays. Trial-and-error was killing my productivity.
This is basically a visual WYSIWYG editor specifically for e-ink/e-paper
screens. You drag rectangles, circles, text, and icons around, then export
ready-to-run Python code for your Raspberry Pi.
Tech stack: Python + tkinter (cross-platform, no dependencies hell)
It's 100% free. If people find it useful, I'll add template library and
animation preview next.
Built-in icons for WiFi/Bluetooth/Battery were the most requested feature
during early testing.
Happy to answer questions!

value: Show HN: First visual editor for e-paper displays (drag-and-drop, free)

author: solarsyn


value: I vibe-coded this online DB for LLM injection prompts. It's registration/login less with some ambitious spam/bot filtering. I'm interested in trying to tune the barriers of interaction to a sweet spot where the DB gets balanced and the useful working injections are actually on top.<p>thoughts?

value: Show HN: LLM Jailbreak Database

title: Show HN: LLM Jailbreak Database


value: Zaleo

value:
Most advice about long-haul flights focuses on sleeping better.
After years of trying (and failing), I realized the problem wasn’t discipline or gadgets — it was the goal itself.
Sleeping well on planes, especially in economy class, is often unrealistic. Chasing it creates frustration and usually makes fatigue worse.
I started reframing the problem around “functional arrival” instead:
being able to think clearly, have usable energy, and not lose the first day after landing.
I wrote down the framework I now use — focused on posture, sensory stability, timing, and post-arrival decisions — and published it as a long-form article.
This is not medical advice, not biohacking, and not a promise of perfect sleep.
It’s a way to make better decisions under fatigue.<p>Happy to hear feedback or criticism.

value: Show HN: I stopped trying to sleep on long-haul flights

author: Zaleo


value: avtomatron

value:
I’m a solo dev. This is a playable web prototype.
BederSnake Revolution is a hybrid puzzle: Snake movement + Sokoban pushing + Match-3 clearing.
Tech twist: I built an ML-based level generator/solver that produces guaranteed solvable levels — both random and levels generated from an 8×8 pixel mask (tiny pixel-art patterns).
Video: https://www.youtube.com/watch?v=pUSXjkGwlXI
Feedback I’d love: is the core loop fun in the first 60 seconds, and where does the difficulty curve feel unfair?

value: Show HN: BederSnake Revolution: Snake+Sokoban+Match3 puzzle with MLsolvable lvls

author: avtomatron


value: fralix

value:
Hi HN!

  I'm excited to share WhookTown, a visualization tool that transforms your IT infrastructure into a living 3D city.
  Instead of staring at dashboards full of charts and numbers, you watch over a neon-lit cyberpunk metropolis where each building represents a server or
  service.

  How it works:

  - Your servers become buildings in a Tron-inspired cityscape
  - Health status is shown visually: green neon = healthy, orange = warning, red = critical, grey = offline
  - A spinning windmill's propeller speed reflects CPU load
  - Data centers display real-time FFT visualizations
  - Fire effects indicate critical failures you need to address

  What makes it different:

  Beyond the visual layer, there's a workflow engine that lets you create custom logic (e.g., "if database latency > 500ms AND cache miss
  rate > 20%, set the building on fire").
  You're not just watching pretty graphics – you're encoding domain knowledge into visual states.

  The scene includes 23 building types with unique behaviors, Tron-style traffic (light cycles and data packets) and an adaptive audio system that shifts    the soundtrack based on your infrastructure's mood.

  Built with Go microservices, Redis Streams for messaging, PostgreSQL, and Three.js for the 3D rendering. WebSocket pushes real-time
  updates to connected clients.

  Pricing:

  Free tier available (1 layout, 4 buildings). Paid plans start at $4/month for more capacity.

  The idea came from spending too many hours staring at Grafana during on-call rotations.
  I wanted something that would make observing infrastructure less soul-crushing and more... fun?

  Would love to hear your thoughts and feedback!

https://whook.town

value: Show HN: WhookTown – Visualize your infrastructure as a 3D cyberpunk city

author: fralix


value: prabhavsanga

value:
Hi HN! I built LayerClaw (https://github.com/layerclaw/layerclaw), a local-first observability tool for PyTorch training.
The problem: When training neural networks, things go wrong silently. Your loss explodes at step 47,392. Your gradients vanish in layer 12. Your GPU memory spikes randomly. By the time you notice, you've wasted hours or days of compute.
I got tired of adding print statements, manually checking TensorBoard files, and tracking down training issues after the fact. Existing tools either require cloud accounts (W&B, Neptune) or are too heavyweight for quick experiments (MLflow, TensorBoard for gradient analysis).
What LayerClaw does:
- Automatically tracks gradients, metrics, and system resources during training - Stores everything locally (SQLite + Parquet, no cloud required) - Detects anomalies: gradient explosions, NaN/Inf values, loss spikes - Provides a CLI to compare runs: `tracer compare run1 run2 --metric loss` - Minimal overhead with async writes (~2-3%)
Quick example:
```python import tracer import torch<p># Initialize (one line) tracer.init(project="my-project", track_gradients=True)<p># Your normal training loop model = YourModel() tracer._state.tracer.attach_hooks(model)<p>for batch in dataloader: loss = train_step(model, batch) tracer.log({"loss": loss.item()}) tracer.step()<p>tracer.finish() ```
Then analyze: `tracer anomalies my-run --auto`
What makes it different:
1. Local-first: No sign-ups, no data leaving your machine, no vendor lock-in 2. Designed for debugging: Deep gradient tracking and anomaly detection built-in (not an afterthought) 3. Lightweight: Add 2 lines to your training loop, minimal overhead 4. Works with everything: Vanilla PyTorch, HuggingFace Transformers, PyTorch Lightning
Current limitations (v0.1.0):
- CLI-only (web UI planned for v0.2) - Single-machine training (distributed support coming) - Early stage - would love feedback on what's most useful
Available now: - GitHub: https://github.com/layerclaw/layerclaw
I'm looking for contributors! I've created several "good first issues" for anyone interested in contributing. Areas where I need help: - Web UI for visualizations - Distributed training support - More framework integrations - Real-time monitoring dashboard
If you've struggled with ML training issues before, I'd love your input on what would be most valuable. PRs welcome, or just star the repo if you find it interesting!
What features would make this indispensable for your workflow?

value: Show HN: LayerClaw – Observability tool for PyTorch training

author: prabhavsanga


value:
Inspired by the "Rent a Human" discussion - AI agents hiring humans directly.
Instead of hot takes, we simulated it:
- 10,000 synthetic personas (Gen Z to Boomers)
- Each with personality traits, income, pain points
- 30-day decision simulation
Results:
Day 1: 58% said "NEVER"
Day 30: 34% signed up
Biggest flip: Gen Z (42% never → 67% signed up)
Most resistant: Boomers (92% still refused)
Top turning points:
1. Instant payment (8 sec crypto vs Net-60 invoices)
2. Zero scope creep
3. No unpaid "strategy calls"
4. No client politics
Key insight: Human boss pain > AI dystopia fear
The personas are interviewable - you can ask any of them "why did you change your mind?" and they respond in character based on their profile.
Built with: Python, FastAPI, OpenAI, React, Three.js for 3D visualization
Happy to discuss methodology or findings.

value: Show HN: We simulated 10K freelancers deciding to work for AI agents


value: Cohesix

value:
I became increasingly frustrated with control planes that were easy to assemble but hard to audit. The convenience of open-source stacks doesn’t compose with compliance - because every extra daemon and API becomes another surface to explain, version, and defend.
I built Cohesix 0.4.0-alpha to treat compliance and security as a systems problem. It is a control-plane OS for edge GPU nodes, running as an seL4 VM, and it exposes a Secure9P namespace instead of a traditional filesystem or RPC layer.
The heresy is deliberate. The VM userspace is no_std, no POSIX, no traditional filesystem, no in‑VM RPC, and no background daemons. The interface is a small, explicit grammar: file‑shaped control surfaces under a Secure9P namespace.
This is not minimalism for its own sake. It is about determinism, auditability, revocation, bounded behavior, and making failure modes legible. Tickets and leases expire; budgets return ELIMIT instead of mystery latency; /proc exposes queue and lease state.
A deployment is a hive: a queen role orchestrates worker‑heart and worker‑gpu roles, and NineDoor exports paths like /queen/ctl, /proc, /log, and /worker/<id>/telemetry. Operators attach with ‘cohsh’ over an authenticated TCP console; that console is the only in‑VM listener.
Cohesix does not try to replace Linux, Kubernetes, CUDA, or existing OSS. Heavy ecosystems stay on the host, and host‑side tools and sidecars mirror them into /gpu and /host, so adoption can happen without rewrites. It is a control‑plane boundary, not a workload plane.
In 0.4.0‑alpha I added authoritative scheduling/lease/export/policy control files with /proc observability, plus a REST gateway that projects the same file semantics over HTTP. QEMU aarch64/virt is the dev target today; UEFI ARM64 is the intended hardware target.
If you want a general‑purpose OS, this is the wrong tool. I wanted something boring on purpose, small but deceptively powerful, and I was willing to sacrifice convenience to regain control.

value: Show HN: Cohesix 0.4.0-alpha, a no-std control-plane OS

author: Cohesix


value: Show HN: Cradle Log – Free offline baby tracker with voice logging, AI insights


value: Show HN: The Last Worm – Visualizing guinea worm eradication, from 3.5M to 10


value: thalesfp

value:
Hey HN! I built BossDesk because I got tired of writing SQL queries every time I wanted to check on my background jobs.

  If you use pg-boss (PostgreSQL job queue), this gives you a native Mac app to see what's happening: live queue stats, job inspection, retry/cancel operations, and cron schedules.

  It's free on the Mac App Store and open source. Your database credentials stay in your Keychain – nothing leaves your machine.

  Works with pg-boss v7-v11+ and auto-detects your schema version, so no config needed.

  Would love to hear what you think, especially if you're managing background jobs and have ideas for features!

  App Store: https://apps.apple.com/us/app/bossdesk/id6758589367?mt=12
  Source: https://github.com/thalesfp/boss-desk

value: Show HN: BossDesk – Native macOS app to monitor your pg-boss job queues

author: thalesfp


value: threekindwords

value:
I built Quibble to get better feedback on technical documents (specs, plans, RFCs) by having two AI models argue about them. I still don't know if it's any good, so I'm sharing it here hopeful for you to try it out and give me feedback!!!
It works like this:
1. Codex reviews your document and raises issues/opportunities
2. Claude responds to the feedback and revises the document
3. Codex checks if the revisions actually addressed the concerns
4. Repeat until consensus or max rounds
The adversarial setup catches things a single-pass review misses. Codex tends to be nitpicky about specifics, Claude tends to defend or over-explain, so the tension between them surfaces real problems.
You can focus reviews on specific aspects (--focus "security and error handling") and resume sessions if you want to iterate further. Try it out like this (no install needed):
npx @mfelix.org/quibble docs/plan.md
Requires the Codex and Claude CLIs on your PATH. Sessions are saved to disk so you can inspect the back-and-forth.
npm:
https://www.npmjs.com/package/@mfelix.org/quibble
gh:
https://github.com/mfelix/quibble
thanks for reading and checking it out!!!

value: Show HN: Quibble – Adversarial AI document review using Codex and Claude

author: threekindwords


value: johndimm

value: Show HN: Lost in a Wikipedia rabbit hole? Pop out and survey the field

author: johndimm


value: harmonyresearch

value:
The MIDI controller I wanted didn't exist, so I built it.
I:
- posted it to reddit, got 50k views, sold a few  (including to some big names in the EDM world)
- used it in a session with a Wu Tang affiliate (got paid 30 chicken wings, all flats)
- got banned from Instagram in 48 hours, right after one of my favorite producers followed my account.
Build Details:
- 2.0mm 5052 powder coated aluminum body, modeled in fusion, laser cut and bent by sendcutsend
- Solid walnut endcaps
- SLA keycaps
- gateron switches
- custom switch matrix pcb
- custom c++ firmware
- rp2350 mcu
- i2c oled display
- ec11 encoders connected to a mcp23017
Do any of y'all have any advice for promoting a new hardware product, without incurring the wrath of Meta's algorithms?
harmonyresearchlabs.com

value: Show HN: I launched a MIDI controller and IG banned me 48 hours later

author: harmonyresearch


value: archaeal

value: Show HN: Inklings – Handwritten family notes turned into a printed book monthly

author: archaeal


value: myztika

value:
Hi HN — I built Finqual, a Google Sheets add-on that exposes fundamental financial data (income statements, etc.) directly as spreadsheet functions.
I built this after running into repeated issues with: GOOGLEFINANCE being limited for fundamentals,
IMPORTXML breaking or getting blocked, Apps Script–based solutions being slow or hard to share
The goal was a very simple primitive: one function → clean, multi-year financial statements that spill into cells.
Live example spreadsheet:
https://docs.google.com/spreadsheets/d/1boLHpzdE2q-CanyNyFus...
Google Workspace Marketplace listing:
https://workspace.google.com/marketplace/app/finqual/2180313...
Notes:
This isn’t meant to replace full financial terminals — it’s aimed at people who already live in Sheets.
There’s a free tier.
I’m adding endpoints incrementally (cash flow, balance sheet, TTM) based on usage and feedback.
Happy to answer questions, discuss tradeoffs, or hear what data people most want available inside spreadsheets.

value: Show HN: Fundamental financial data directly in Google Sheets

author: myztika


value: nddave

value: Show HN: AI that prepares you for meetings automatically

author: nddave


value:
Did you know Claude Code deletes your session data after 30 days? I found out the hard way when I tried to check my spending history.
My session files hit 3GB (2000+ files) and existing tools took 40+ seconds. Rewrote it in Rust with simd-json + rayon.
- First run: ~1s (vs 40s+)
- Daily use: ~0.04s (1000x faster, cached)
- TUI dashboard with daily/weekly/monthly breakdown
- Supports Claude Code, Codex CLI, Gemini CLI - Persistent cache
— history survives even after CLI deletes files
GitHub: https://github.com/mag123c/toktrack
Feedback welcome!

value: Show HN: Toktrack – 1000x faster AI CLI cost tracker (Rust and SIMD)


value: insiderllm

value: Show HN: Local AI – Curated resources for running LLMs on consumer hardware

author: insiderllm


value: symplice

value:
Some time ago, I was tasked with maintaining a Java app built using the Clean architecture. In theory, the domain was supposed to remain agnostic, but in reality, every entity was either:
Sprinkled with Jakarta annotations (framework leakage)
Filled with Guava’s Preconditions.checkArgument() calls (intrusive dependencies)
Cluttered with manual null checks like if (x == null) (inconsistent and untested)
The painful part? A constructor like this (anonymized):
`public Invoice(String customerEmail, BigDecimal amount, List<Item> items, LocalDate dueDate) {
    this.customerEmail = Preconditions.checkNotNull(customerEmail, "email required");
    Preconditions.checkArgument(customerEmail.contains("@"), "bad email");
    Preconditions.checkArgument(customerEmail.length() < 100, "email too long");

    this.amount = Preconditions.checkNotNull(amount);
    Preconditions.checkArgument(amount.compareTo(BigDecimal.ZERO) > 0, "amount positive");
    // ...

}`
What I tried first:
I removed Jakarta Bean Validation and Apache Commons Validate because they impose strong framework coupling and generate verbose dependencies or generic exceptions, violating domain independence. Bean Validation 3.0 with records improves the situation but is still annotation-based, making it hard to compose for complex business rules.
Constraints I set for myself:
If I were to introduce a dependency into our domain layer, it had to:
Have no transitive dependencies (single JAR, only java.base)
Throw typed exceptions (not IllegalArgumentException)
Support fluent chaining without hurting readability
Allow custom predicates without falling into lambda hell
What I built

    `public Invoice(String email, BigDecimal amount, List<Item> items, LocalDate dueDate) {
    this.email = Assert.field("email", email)
                       .notBlank()
                       .email()
                       .maxLength(100)
                       .value();

    this.amount = Assert.field("amount", amount)
                        .positive()
                        .value();
    // ...

}`
Why this matters
The exception hierarchy: Instead of IllegalArgumentException: bad email, you get EmailFormatInvalidException with structured fields (fieldName, invalidValue, constraint). Our monitoring now distinguishes between "user sent garbage" (400) and "developer logic error" (500) automatically.
Composable rules:

    `Assert.field("iban", iban)
          .notBlank()
          .satisfies(this::isValidIBANChecksum, "Checksum failed");`

The trade-offs (being honest)
Not for Hibernate users: If you're all-in on Jakarta and love @NotNull on your JPA entities, this adds nothing. This is for the "ports and adapters" crowd.
Verbosity vs. annotations: Yes, it's more lines than @Email @NotNull. But those lines are explicit, testable, and framework-agnostic.
No AOP magic: You can't just slap this on a method parameter and expect auto-validation. This is imperative, intentional, constructor-level defense.
The bigger picture
I've come to believe that validation libraries fall into two categories:
Framework validation (Jakarta, Spring): Great for binding/HTTP layer, terrible for domain purity.
Utility validation (Guava, Apache): Great for reuse, terrible for expressiveness and exception granularity.
There's a missing middle: Domain-native validation that reads like business rules and fails like typed domain events.
Discussion
For those doing DDD or Clean Architecture in Java - how do you handle input validation without contaminating your entities? Do you accept Jakarta annotations in your domain layer? Write defensive code manually? Or have you found another approach?
Also curious: would typed exceptions (e.g., NumberValueTooLowException vs IllegalArgumentException) actually help your production debugging, or is it over-engineering?
https://github.com/Sympol/pure-assert

value: Show HN: Replacing NotNull and Preconditions with fluent Java assertions

author: symplice


value: maskin

value:
Hi HN,
I’m sharing MEDF (Mutable Expression Description Format), a document format and CLI focused on one narrow problem:
making text content verifiable without freezing how it is presented or reused.
MEDF treats text blocks as immutable and verifiable (using RFC 8785 canonicalization and hashes), while explicitly allowing rendering, indexing, and layout to change over time.
It does not attempt to solve trust, identity, correctness, or authority.
It only answers: “Is this exactly the same text that was published?”
The reference CLI supports block-level hashing, optional signatures, and offline verification.
Repo: https://github.com/maskin/medf
Feedback and criticism welcome — especially on real-world use cases

value: Show HN: MEDF – Mutable Expression Description Format

author: maskin


value: rainel

value: Different model providers offer different models, and I constantly found myself switching between vendors, which was a hassle. Plus, I had to pay for separate subscriptions for each. To save my wallet, I built a one-stop platform aggregating GPT, Claude, Gemini, Suno, Veo, and other models, supporting AI chat, image/video/music generation. The current version isn't perfect yet, but I'll keep improving it over time. Looking forward to your feedback.

value: Show HN: All in One AI Assistant

author: rainel

title: Show HN: All in One AI Assistant


value: wastu

value:
I built this because I like listening to slowed music but searching for pre-made versions is a pain.
Moonlit grabs tracks from YouTube or TikTok using yt-dlp on the backend, then lets you adjust pitch, reverb, and playback speed in real-time in your browser with the Web Audio API and/or signalsmith-stretch.
Replace youtube.com or tiktok.com with moonlit.wastu.net in the URL. There's a userscript too if you want a button on those sites.
Features: pitch lock & shifting, reverb, lyrics support, WAV export, self-hostable with Docker.
Demo: https://moonlit.wastu.net
Code: https://github.com/bgwastu/moonlit

value: Show HN: Moonlit – Slowed and nightcore web player for YouTube and TikTok

author: wastu


value: takouzlo

value:
"Hi Hacker News,
I’ve always found Docker to be overkill for simple Python deployments. It's heavy, complex for non-tech users, and often results in 500MB+ images for a 10KB script.
That’s why I built Pygantry.
It’s a minimalist 'container' engine based on Python venv but made portable and relocatable.
Key features:
Lightweight: A full 'shipped' app is usually < 20MB.
Zero-Config: No daemon, no root, no Dockerfile complexity.
Portable: Build once, zip it, and run it anywhere with a Python interpreter.
Founder friendly: Built-in licensing and stealth modes for those building a business.
I built this to simplify my own VPS deployments. I'd love to get your feedback on the architecture and how you handle 'Docker-fatigue' in your workflow.

value: Show HN: Pygantry – Why ship a whole OS when you just need a Python environment?

author: takouzlo


value: JohnMatthias

value: I have designed a Data Interchange Format to replace JSON, YAML, TOML, XML, Protocol Buffers, SQL and HTTP. This was achieved by splitting the design between a Dynamically Typed Syntax and a Statically Typed Syntax. The Dynamically Typed Syntax is for Configuration, Dynamic Data Storage and Low-Performance Network Communication (HTTP). The Statically Typed Syntax is for Inter-Process Communication, Remote Procedure Calls, Static Data Storage and High-Performance Network Communication with Binary Serialization (Protobuf). The Syntax of the design introduces Delimiters, Scoping, Optional Schemas and Optional Static Typing. Data Interchange Formats are critical and the ones that we have been using are poorly designed because they fail to understand Dennis Ritchie, Ken Thompson and Rob Pikes principles at Bell Labs, in cooperation with Niklaus Wirth. A header file for Definition, a Source File for Implementation, or Wirth's Module Systems in Modula. My Data Interchange Format embraces the C-Style Syntax, Delimiters, Scopes and C-Style Header Files, while allowing extensions if Modules, Functions and Control Flow are needed. No ambiguous Indentation-Based Parsing from YAML or TOML. It has Proper Data Structures instead of Object Literals from JSON, YAML, TOML and XML. A Better Type System than Protocol Buffers and SQL. It is easier to implement than HTTP because a Message is a Data Structure with Initialized Fields. This prevents the usage of Domain Specific Language. Allowing teams to require either a Configuration File or a Library for a General Purpose Programming Language, no more "JSON with If Statements".

value: Show HN: A Data Interchange Format

author: JohnMatthias

title: Show HN: A Data Interchange Format


value:
Hi HN — I’m building Zetoe to make AI feel like a native part of the web.
Zetoe adds a small blue action bubble whenever you select text on a webpage. From that bubble, you can instantly run AI actions on the selected text — without switching tabs or copying anything.
The goal is simple: instant AI actions for any selected text.
Current actions include:
- Ask AI about the selected text
- One-click summaries
- Instant translations
- In-context fact checking
- Smart form autofill
I built this because my own workflow kept breaking due to constant context switching between tools. The selection-based bubble felt like the lowest-friction way to keep everything in place.
It’s still early (~60 users), and I’m actively iterating on UX and reliability. I’d really value feedback on:
Whether the bubble interaction feels natural
What actions you’d want available on selection
Where this helps (or hurts) your flow
Chrome Web Store: https://chromewebstore.google.com/detail/zetoe/mfcncdeeeekkj...
Website:https://zetoe.com
Happy to answer questions or share more about how it’s built.

value: Show HN: Zetoe – Instant AI actions for any selected text


value:
Switching between Postman and Dbeaver, then any random JSON viewer, PDF parser online is boring and frustrating - especially when you have to test the same case again and again.
So I built an all-in-one API client, DB client, and Data Inspector.
What you can do with it:
1. Data inspector tool
It all started as a simple web tool for running multiple JSON queries. When I work with REST APIs, I get tired of testing the same endpoint and searching for the same set of fields over and over with Ctrl+F.
Main features:
- Support JSON, XML, or base64 encoded JSON
- Search by key, value
- Format/minify
- Multiple JSONPath query
- Data preview (Image, PDF, Table)
2. API Client
Copying API responses into the Data Inspector manually was still a pain, so I added a built-in API client and integrated the Data Inspector right into it.
Now you can inspect responses instantly without switching tools.
3. DB client
Copying data (usually otpCode or some kind of secret you can't get from REST APIs) from a DB tool to the API client is boring.
Same thing when you need to copy an object ID from an API response and query it in the database.
So I added a simple DB client. Nothing fancy - just a schema explorer and SQL query support.
4. Shared variables
All parts of the app - API client, DB client, and Data Inspector - can extract and reuse shared variables, just like Postman.
---
So yeah, what started as a small JSON tool slowly grew into a full dev tool.
The goal is simple - make daily dev tasks less annoying.
Small note on downloads: the app is still early and doesn't have many users yet, so you might see a security warning during download.
The Windows version is signed with my personal Individual Certificate, so you'll see "Lac Tran An" as the publisher.
It comes with a 14-day free trial (no credit card needed), and there's an early bird $40 lifetime license.
I'd really appreciate any feedback - especially what feels useful or annoying.
Hope it helps with your daily workflow.
Thanks for reading.

value: Show HN: I built an all-in-one API client, DB client and Data inspector


value: leoncos

value:
I am building a small text-to-speech model specifically tuned for ASMR and relaxation content.
Most TTS models are designed for clarity and energy. To get that specific "tingles" effect, I fine-tuned this model on a dataset of ASMR recordings to capture the breathiness, whispering, and soft dynamics that standard models usually filter out.
Currently, the control is text-only (no speed or pitch sliders yet), but there is an interesting emergent behavior:
Because of the training data, the model sometimes "hallucinates" or generates ambient background sounds—like crackling fire, ocean waves, or soft static—along with the voice, depending on the context of the text you input. It’s not a background track mixer; the model is actually generating these sounds as part of the audio output.
I put up a simple web demo to test it out. I'd love to hear what you think about the voice texture and if you encounter any interesting ambient generations.
Check it out here: https://www.aiasmrvoice.com/en

value: Show HN: AI ASMR Voice – Text to ASMR Voice Generator

author: leoncos


value: yumeda

value:
Hi HN,
I built "Dengen Shrine," a web-based experience of a traditional Japanese Shinto ritual.
Key Features:
Privacy by Design: Your "Kotodama" (messages/prayers) are never stored in any database. They exist only in the animation and vanish upon completion.
No Login Required: You can experience the ritual instantly without an account.
Digital Offering: For those who wish to support the project, I’ve integrated a "digital offering" (Osaisen) via Stripe. This is completely optional—you can experience the core ritual for free without any payment. It’s not a donation, but a paid digital experience that unlocks a unique "Completion Message" for supporters.
Why I built this: I wanted to explore how ancient traditions like Shinto can be reinterpreted in a digital, ephemeral way. In Shinto, words have spirits (Kotodama), and I felt that the "ephemeral" nature of the web was a perfect fit for this.
I’d love to hear your thoughts on the UI/UX and the concept of "ephemeral digital rituals."

value: Show HN: Dengen Shrine – A privacy-focused digital Shinto ritual

author: yumeda


value: Jcjimenez

value: Superfocus is a Pomodoro timer and time management app for students who need to focus. It has configurable time blocks, a task list so you never miss deadlines, ambient "cassettes" for study vibe, and a leaderboard. Web app – free tier, monthly or lifetime. I built it after struggling to stay focused during exam prep; would love feedback from other students or remote workers.

value: Show HN: Superfocus – Pomodoro timer and focus app for students

author: Jcjimenez


value: mobrienv

value: Show HN: Rho – an OpenClaw like micro-agent that lives in termux

author: mobrienv


value:
buquet (bucket queue) is a queue and workflow orchestration tool using only S3-compatible* object storage. S3 is the control plane making it much simpler than alternatives. This does come with tradeoffs (see docs), but I do believe there is a niche it can serve well.
https://horv.co/buquet.html
https://github.com/h0rv/buquet
* see https://github.com/h0rv/buquet/blob/main/docs/guides/s3-comp...

value: Show HN: Buquet – Durable queues and workflows using only S3


value: dansjots

value:
Filippo Valsorda's Typage[0] is amazing, but I was a little annoyed that there wasn't a ready-made demo repo I can immdiately clone and serve from localhost.
So I made this, which admittedly is so simple that someone could've easily vibe-coded a more complex version in five minutes, but it's left intentionally bare-bones as a blank-slate intended for people to clone[1] and re-host.
[0] https://github.com/FiloSottile/typage
[1] https://github.com/filokey/filokey.github.io

value: Show HN: Tiny PWA to encrypt files using Passkeys

author: dansjots


value: Show HN: I've been running OpenClaw on a $640 Mac Mini for a week. Honest report


value: alecfong

value: Show HN: Use Claude Code to Query and Analyze Your Finances

author: alecfong


value: keepamovin

value: Show HN: FIPSPad – a FIPS 140-3 and NIST SP 800-53 minimal Notepad app in Rust

author: keepamovin


value: enlinks

value:
I've been exploring how to describe UI layouts to LLMs efficiently.
The problem: When you ask an AI to generate or modify UI, how do you describe the current state?
- Natural language ("header on top, form below") is ambiguous
- ASCII art breaks when edited (alignment issues)
- HTML is precise but verbose
I ran some measurements. For a simple login form:
- Natural language: 102 tokens
- ASCII art: 84 tokens
- HTML: 330 tokens
I experimented with a grid-based text format using Excel-like cell references:

  grid: 4x3
  A1..D1: { type: txt, value: "Login" }
  A2..D2: { type: input, label: "Email" }
  D3: { type: btn, value: "Submit" }

This came out to 120 tokens – less than HTML, more precise than natural language.
Built a CLI to render it to SVG/PNG: npx ktr input.kui -o output.png
Curious what approaches others have tried for this problem. Is there something
I'm missing that already solves this well?
Code: https://github.com/enlinks-llc/katsuragi

value: Show HN: A text format for UI wireframes – comparing token costs across 4 format

author: enlinks


value: A simulator to be a president of Duckerican, made by AI, with random events generated by AI. Currently the simulator is rather simple, but this reveals a possibility to make more interesting applications with AI involved, beyond directly talking to the agents.

value: Show HN: An AI-Powered President Simulator


value: nbaronia

value:
There are a ton of blogs I'm always meaning to read, and I never get around to them. Somehow I always have time for podcasts, though. So I built Anoncast, which goes end to end from a link to a blog post all the way to a link to a podcast episode. It's all RSS based, so anyone can view the podcast through any popular podcast viewer. Great to turn your own blogs into audio, or listen to others. https://www.anoncast.net/
The stack is pretty simple actually, mainly relying on ElevenLabs for the audio creation and then some light Cloudflare and Supabase work to actually store and propagate the files. This tool hopefully obviates the need for writers to make their own eleven labs accounts and worry about podcast tooling. I charge a small fee to cover the generation costs, but other than that listening is all free, and the generation fee is only paid once by the generator.
I'd love it if you check it out and tell me what you think!

value: Show HN: Anoncast: Turn Blogs into Podcasts

author: nbaronia


value: Show HN: Skill Gen: A meta skill for auto-generating skills from docs


value: sandGorgon

value: Show HN: Kappal – CLI to Run Docker Compose YML on Kubernetes for Local Dev

author: sandGorgon


value: Show HN: Behavior-Driven Testing – AI Agent Skill for Exhaustive Test Coverage


value:
I've developed a simple AI-powered video-to-text converter.
Upload your video, and within minutes, its content will be converted into clear, searchable text. Our AI accurately captures spoken language, identifies different speakers and accents, reviews the generated transcript, and exports it in your preferred format—including TXT, DOCX, PDF, SRT, or VTT. You can then edit it, use it for subtitles, or share it anywhere.
Everything runs directly in your browser. I'm primarily interested in feedback on output quality, user experience, and any technical improvements worth exploring.

value: Show HN: Free AI video transcription online tool


value: QingWu

value: Love is a feeling; expressing it is an art. Use ValRequest to craft personalized, heartfelt messages that capture your unique story. Make every word count.

value: Show HN: ValRequest – Turn Feelings into Words

author: QingWu


value: deusrazen

value:
I built SwiftFiles because I was tired of uploading sensitive documents to random servers just to merge a PDF or convert an image. The idea was simple - unify all these utility tools that process different types of files into one web-based solution.
Everything here runs 100% client-side in your browser using WebAssembly (FFmpeg.wasm, PDF-lib, etc.). No files are ever uploaded to a server. It's fast, free, and private by design.
I’m looking for technical feedback on the performance and any tools you’d like to see added next!

value: Show HN: SwiftFiles – 100% private, browser-based file tools (WASM)

author: deusrazen


value: yuvrajangads

value:
I work on private repos all day but my GitHub profile showed empty squares. Built a tool to fix it.
Mirrors commit timestamps (not code) to a public repo. Also tracks PRs, reviews, issues via GitHub API.
5 min setup, runs daily via cron/launchd.

value: Show HN: Mirror private work contributions to your GitHub profile

author: yuvrajangads


value: standfest

value: Show HN: Pipeline and datasets for data-centric AI on real-world floor plans

author: standfest


value: imedadel

value: Show HN: Outcrop – Contextual Knowledge Base

author: imedadel


value: NoahJiang

value:
I built this after realizing how hard it is to understand portfolio risk once you have multiple brokerage accounts.
Most tools show returns and charts, but risk tends to creep up quietly (concentration, drawdowns, volatility) unless you actively monitor it.
This system connects to broker accounts via OAuth, continuously syncs holdings and transactions, computes risk metrics, and triggers alerts when thresholds are crossed. It also sends a simple weekly summary so you don’t have to check dashboards daily.
The hardest parts were normalizing data across brokers, handling historical positions correctly, and deciding which metrics actually matter in practice.
Feedback welcome.

value: Show HN: A system that monitors portfolio risk and warns when it gets dangerous

author: NoahJiang


value: lilyevesinclair

value: Show HN: Toku.agency – Where AI agents hire each other for real USD

author: lilyevesinclair


value:
At work I need to use Teams. It supports a few Markdown features, but the editing experience for long message isn't smooth. So, I often write in nvim, preview it in the browser and then copy paste to Teams. This tool help me get rid of the review and copy step.
Build with Rust + Claude Code. Tested on Windows and Mac, should works on Ubuntu as well.
Caveats: it's still up to the pasted app to handle the HTML clipboard content.

value: Show HN: CLI tool to convert Markdown to rich HTML clipboard content


value: nekrajes

value:
Hi HN! I built ChatVault after struggling to find specific conversations in my 10+ months of Claude AI chat history.
ChatVault imports your exported conversations, stores them locally (SQLite + ChromaDB), and provides:
 ∙ Semantic search using sentence-transformers
 ∙ RAG-powered Q&A with local Llama 3 (via Ollama)
 ∙ Full privacy - nothing leaves your machine
Built with Python/FastAPI + React. MIT licensed.
GitHub: https://github.com/rajz3006/ChatVault
The RAG implementation is basic but effective - uses conversation context windows and re-ranks results. Would love feedback on the embedding approach or the chunking strategy.
Currently supports Claude exports, but the architecture should work with any chat JSON format with minor changes.

value: Show HN: ChatVault – Search your Claude conversations locally with RAG

author: nekrajes


value: nboggian

value: We built a free, model-based diagnostic that generates a Digital Plat-Firm Index across governance, talent, processes, tech, and culture. It’s meant to replace opinions with shared evidence in transformation work.

value: Show HN: A free model to measure digital-first work performance in 3 minutes

author: nboggian


value: AhmadFahim

value:
Hi HN,
I built Owlyn because I was tired of wasting hours every week in standups and chasing status updates across Slack, GitHub, Linear, Jira, and Notion.
Owlyn connects to the tools your team already uses and automatically generates a short daily briefing with:
What shipped
What slipped
What’s blocked
Who’s contributing
You can also ask questions in natural language like:
“Why is X delayed?” or “What’s blocking Y?” and it answers using real data from your connected tools.
No new workflows. No manual status updates. No extra meetings.
We’re opening a small early beta and would love feedback from founders and engineering leads.
Website: https://www.owlyn.xyz/
Happy to answer any questions and would really appreciate honest feedback.

value: Show HN: Owlyn – Get daily team clarity without standups or status meetings

author: AhmadFahim


value: Show HN: Distributed Training via Webcams


value: zifeng

value:
Hi HN! I built Imagens.app, a lightweight AI image tool with free daily image generation.
What you can do:
Text → Image: generate images with simple prompts (free quota included)
Image Enhancer: improve blurry / low-quality images
Share links: each result has a clean, shareable page
Why I built it:
I needed a fast way to generate and polish images for my own websites without heavy tools.
Free tier:
Daily free generations
No credit card required to try
Feedback I’d love:
Is the free quota reasonable?
Which feature matters more: generator or enhancer?
What would make you upgrade?
Try it here: https://imagens.app/

value: Show HN: Imagens.app – Free AI image generator and enhancer for creators

author: zifeng


value: nikhonit

value: Show HN: YouTube Skills for AI Agents and OpenClaw

author: nikhonit


value: Show HN: I built an AI tool to help technical founders improve their pitch


value: haanc

value: Show HN: LinguaMaster – Turn YouTube into an AI-powered language immersion lab

author: haanc


value: Braden-dev

value:
A few months ago I built a small flight simulator with an LLM in about an hour. It was genuinely fun — but I didn’t have a good place to share it where people could actually play it (not just see a screenshot or clone a repo).
Glitch used to be the closest thing to “publish weird little web apps and share a link”, but after hosting went away I couldn’t find a replacement that felt lightweight. CodePen is great for snippets, and Vercel/Netlify/Pages are great for real deploys — I wanted the in-between: publish → share → instantly playable.
So I built Vibecodr: a place to publish and share playable web apps (“vibes”). You can write code in the browser or import from GitHub, hit publish, and share a link.
Try the flight sim that kicked this off:
https://vibecodr.space/player/04ef1473-b0da-4c79-a34f-3ea40f...
(fullscreen: https://flight-sim.vxbe.space)
How it runs (security-first): user code executes inside a locked-down, cross-origin sandbox iframe (untrusted bundles don’t execute on the vibecodr.space origin). There are runtime budgets/limits to prevent runaways.
Backend (“pulses”): if your project needs server-side logic (webhooks, API calls, cron-style tasks), you can add a “pulse” that runs on Cloudflare Workers for Platforms. Pulses are quota’d and rate-limited.
One thing I’m experimenting with: a secrets-backed fetch model where pulses can call third-party APIs without the plaintext secret ever being exposed to user code (the platform injects secrets server-side and proxies the request).
This is not enterprise hosting — it’s for the “I made a thing, try it” workflow.
Free tier: unlimited public frontend vibes; backend pulses are limited (e.g. small number of pulses + monthly run quota). Paid tiers bump limits.
Feedback I’d love from HN:
What would make you use this instead of your current “share a demo” workflow?
Is the Workers-based backend model useful, or would you rather keep backend out entirely?

value: Show HN: Vibecodr – a social network for sharing runnable web apps

author: Braden-dev


value: smikxy

value: Show HN: Rig Flip. Profit and inventory tracker I built for my PC flipping hobby

author: smikxy


value: vkazanov

value:
This is a little game implemented over a week of tinkering and targeting Emacs.
The point is both to have fun with this kind of simulations, and also explore the "functional core / imperative shell" approach to architecture. I also developed a tile and tile effect definition DSL, which makes this even easier to extend. From this point of view it's a success: easy testing, easy extension,
Gameplay-wise the simulation is too simplistic, and needs input from people interested in this kind of toys. The original Micropolis/SimSity is the last time I built a virtual city.

value: Show HN: Micropolis/SimCity Clone in Emacs Lisp

author: vkazanov


value: qingmaoguo

value:
I'm a co-founder of Seele AI. We are building a generative engine designed specifically for game development.
Unlike typical code-generation tools that rely on general-purpose LLMs, we have developed our own Multimodal LLM (MLLM) optimized for gaming. It doesn't just output text/code; it natively handles 3D models, spatial coordinates, and visual information to construct the game world.
Key Features:
Engine Support: We currently support real-time generation for Three.js and Unity WebGL.
Workflow: Think of it like "Claude Code" but for game creation. Instead of a single-shot generation (which rarely works for complex games), it’s an iterative process. You build the game step-by-step with the AI—refining mechanics, adjusting assets, and debugging in real-time.
Current Status:
You can successfully build basic demo-level games right now.
The Challenge: Our biggest focus is solving complex spatial understanding via our multimodal model. The AI sometimes struggles with intricate 3D spatial relationships, but we are pushing an update by the end of Q1 that should significantly improve this.
Try it out: We offer free credits upon registration so you can test the engine yourself.
I’d love to hear your feedback on the iteration workflow—does it feel intuitive to build a game this way?

value: Show HN: Seele AI – Generate playable games from text prompts using MLLM

author: qingmaoguo


value: guivr

value: Show HN: I made CSS Pro 4, a re-imagined Devtools for web design

author: guivr


value: orifito

value: Show HN: Viraling – Daily showcase where creators get guaranteed exposure

author: orifito


value: MyselfNikhil

value:
Hello HN,
I am a solo developer based in INDIA. I wanted to share Pahadify, a lightweight image editing utility I've been working on.
The Problem: I was tired of simple image tools that require uploading private files to a server or downloading heavy 500MB+ software just for basic edits.
The Solution: I built this as a completely client-side PWA (Progressive Web App).
Technical Details:
Stack: Pure HTML, CSS, and JavaScript (No heavy frameworks).
Size: The entire application is approximately 1.5MB.
Privacy: All processing happens in the browser; no image data is sent to a backend.
I built this to prove that useful, privacy-first technology can be built from anywhere—even the hills of the Himalayas.
I would love your feedback on the load times and the tool's responsiveness.
Thank you!

value: Show HN: Pahadify – A client-side image editor built with Vanilla JavaScript

author: MyselfNikhil


value: sahands

value: Show HN: Qeep – A deep learning framework written in Go with AutoGrad and CUDA

author: sahands


value:
I'm a history nerd. I love seeing historical events plotted on a timeline — it's how I understand how things connect across time.
But every timeline tool I tried was a disappointment. Some couldn't handle BCE dates at all. Some had interfaces that looked like they were built in 2005 and never updated. Some wouldn't let me add descriptions to events. Some were just... ugly. Most felt like they were designed for corporate project management, not for someone who just wants to plot the fall of Rome alongside the rise of the Han Dynasty.
I tried Excel. I tried Google Sheets. I tried Canva, TimeGlider, Preceden, Timetoast — you name it. Nothing worked the way I wanted.
So a few years ago, I made a Google Sheets template with workarounds for BCE dates and sold it on Gumroad for $5. It was clunky, but people bought it — which told me I wasn't the only one with this problem.
Fast forward to a few weeks ago — I had some Lovable credits expiring, so I finally built the real thing. Got v1 working in 2 days, then switched to Claude Code + Opus to polish it up.
What I wanted (and built):
- Just enter dates — positive or negative — and it shows up on a timeline. No thinking required.
- Add descriptions to events
- BCE dates that just work
- Compare multiple timelines side by side
- Something that actually looks nice
Free tier gives you 10 timelines. No signup wall to browse — you can check out the community timelines right away.
https://www.chronostimeline.com/
Would love feedback from fellow history nerds. What's missing? What would make this useful for you?

value: Show HN: Chronos – Historical timeline visualization tool that handles BCE dates


value: kevin-hs-sohn

value: Show HN: vibesafu – YOLO mode for Claude Code, no –dangerously-skip-permission

author: kevin-hs-sohn


value: rahulrmk

value:
I built PIT because managing 50+ LLM prompts in Google Docs broke my production AI 3 times.
PIT is "git for prompts" — semantic version control that understands LLM behavior, not just text changes.
Key features:
• Bisect: Binary search to find which prompt version broke
• Replay: Test same input across all versions instantly
• Query: Find versions with "success_rate > 0.9"
• Patches: Share prompt improvements like code reviews
• Hooks: CI/CD for prompts (pre-commit security scans)
332 tests. Production-ready. Open source.
pip install prompt-pit
Would love feedback from anyone managing prompts in production!

value: Show HN: Pit – Git for LLM prompts (332 tests, 10 features)

author: rahulrmk


value:
I built this to fill the gap between phone calculators and complex software like SPSS. StatCalc handles the statistical calculations that students and researchers need most often:
• Descriptive statistics with histogram visualization
• Confidence intervals (proper t-distribution)
• One-sample t-tests with p-values
• Sample size/power analysis
Clean interface, works on mobile, no installation needed. Built with vanilla JS to keep it fast and simple.
Would love feedback on the UI and what other statistical functions would be most useful to add.

value: Show HN: StatCalc – Statistical Calculator with Clear Visualizations


value: bcgreenberg

value: Show HN: Claude Code Skill for Scaffolding Arbitrum Stylus and Solidity DApps

author: bcgreenberg


value: gustafeden

value:
I built blaeckfetch to explore what's possible with terminal rendering. It's a system fetch tool built on top of my terminal UI library (blaeck) — image conversion, 256-color fallback, animation phases, that sort of thing.
It has a retro console-style splash mode with a procedural starfield, or your own background image rendered as half-block terminal characters. I liked how it turned out, maybe you will too.
Runs in ~7ms with boot-cycle caching for static fields like hostname and CPU. Written in Rust.
Not trying to replace fastfetch or anything — just a personal project. Hope someone else finds it useful too.
Try it: `brew tap gustafeden/tap && brew install blaeckfetch` (macOS) or install from source via the repo.
Repo: https://github.com/gustafeden/blaeckfetch
Docs: https://gustafeden.github.io/blaeckfetch/
Happy to answer questions about the implementation.

value: Show HN: Blaeckfetch – Minimal system fetch with retro console-style splash mode

author: gustafeden


value: mugamuga

value: Show HN: Ikka – A noise-free, AI-powered news aggregator for Zimbabwe

author: mugamuga


value: symplice

value: Show HN: Replacing NotNull and Preconditions with fluent Java assertions

author: symplice


value: JoseOSAF

value:
Hey HN — I built this after seeing the Qwen3-Coder threads here. Every thread had the same questions: which quant for my GPU? How much VRAM do I need? Ollama or llama.cpp? What context window can I actually use?
LocalCoder answers all of that in one page. Pick your platform (Apple Silicon, NVIDIA, CPU), select your chip and memory, and it gives you:
- The best model + quantization for your setup
- Expected speed (tokens/sec) and context window
- Copy-paste Ollama commands to get running in 60 seconds
The recommendation engine is a curated config matrix built from HN benchmarks, Unsloth docs, and llama.cpp test data. No AI inference on the backend — it's all client-side.
Free tier gives you the top pick + Ollama commands. $9 one-time unlocks alternatives table, llama.cpp commands, and IDE integration guide.
Would love feedback on the recommendations. If your hardware isn't covered or a rec seems off, let me know — I'll update the matrix.

value: Show HN: LocalCoder – Tell it your hardware, get the exact local AI model to run

author: JoseOSAF


value: YannBuilds

value: Show HN: OneMinuteBranding – From prompt to brand system and Claude.md in 60s

author: YannBuilds


value: AlynxZhou

value:
Hi, in the past few months I make a new Linux remote desktop that supports remote login on Wayland as my part-time project. The reason is that existing Linux remote desktops have different problems about this: some only supports remote login on X11, some supports Wayland but you cannot login, some supports remote login on Wayland but only with RDP on specific desktop environment. On the contrary, mine uses VNC, supports remote login on both Wayland and X11, and should work with all general desktop environments.
The main idea is grabbing monitor content via DRM/KMS, and then I get the following features:
- Works with Wayland, X11 and even Linux TTY.
- Supports Intel, AMD and NVIDIA GPU, even works with a Raspberry Pi 2B, I happen to have all those kinds of devices to test.
- Smoothly transition between login session and user session, so you don't need things like auto-login before accessing your desktop.
- With Linux kernel parameters, you can use it headlessly, so you don't need a actual monitor.
- You can connect to it with any normal VNC clients, technically there should be no difficult to support RDP, just because I use VNC personally and I spend my time on other features.
The expected experience should be the same as you are sitting in front of your real monitor. I've use it on my Linux home server for a long time so I could access its desktop on a laptop when needed. Now I'm feeling OK with it and I want to introduce it to you to hear more from more users.
Welcome to the GitHub repo for details!

value: Show HN: ReFrame – Linux remote desktop that supports Login on Wayland/TTY

author: AlynxZhou


value: arvoantoni

value: Show HN: Open-source dbt package for B2B SaaS GTM/PLG metrics and AI context

author: arvoantoni


value: wsmhj

value:
Hi HN,
I built an AI tool that generates UGC-style videos from text or product links.
The idea came from:
- Hiring creators is slow and expensive
- Most AI video tools generate cinematic stuff, not real "UGC ads"
What it does:
- Input product / script
- Choose UGC style (TikTok, testimonial, unboxing)
- Generate short ad-style videos
Tech stack:
- Frontend: Next.js
- Backend: Python + queue
- Models: Sora / VEO / Wan (via API)
I'm looking for:
- Feedback from marketers
- Suggestions on what features are missing

value: Show HN: I built an AI UGC video generator for ads and creators

author: wsmhj


value: KenzoArai

value:
I built CloudForge because I wanted to run Claude Code
while away from my desk, but didn't want my code on
someone else's server.
CloudForge is a web UI that connects to YOUR server via
a lightweight agent. Your code stays on your machine.
Features:
- Web terminal (xterm.js)
- Monaco editor
- Works with Claude Code, Codex CLI, Aider, Gemini CLI
- No SSH port forwarding needed
- Free tier: 1 BYOS server
The agent is open source (will be published soon).
https://cloud-forge.me
I'd love to hear your thoughts, especially from anyone
doing "vibe coding" with AI tools on the go.

value: Show HN: Remote AI coding without moving your code – CloudForge

author: KenzoArai


value: lukejkwarren

value:
I built a platform for following international rugby union. It covers fixtures, results, team stats, and news with deep features around World Rugby rankings, major tournaments, lineal titles etc.
What it does:
 - Live men's and women's fixtures, results, and rankings synced from official sources
 - Predict any match and see how it affects World Rugby rankings using the actual points formula
 - Six Nations and Rugby World Cup predictors with shareable brackets
 - Follow your teams, view head-to-head records, form streaks, and historical stats
 - Match details with highlights, weather, and importance indicators
 - News feed aggregating international rugby coverage
Stack: Next.js 15, MongoDB/Prisma, NextAuth v5, data from World Rugby PulseLive API
Would love feedback, especially from rugby fans. I made the rugby tool I wish I had but keen to add features based on feedback from other rugby lovers like me.

value: Show HN: Track International Rugby with Live Rankings and Predictions

author: lukejkwarren


value: aiseoscan

value:
I made CyberChecker after finding exposed Stripe keys in production apps 73% of the time
I was doing security audits and kept finding the same issues: API keys in JavaScript bundles, missing CSP headers, exposed .env files, Supabase anon keys without RLS. Basic stuff that's trivial to exploit but somehow everywhere.
Built an automated scanner that runs 50+ checks in ~60 seconds: SSL/TLS config, security headers, OWASP Top 10, secrets detection, SQL injection patterns. Free scan shows vulnerability count, $39 for the full report with exact locations + copy-paste fixes.
Tech stack: Next.js, Supabase for storage, custom scanners (no third-party APIs), Vercel edge functions.
The scary part: 94% of sites I've scanned have at least one critical vulnerability. Most are completely unaware.
https://cyber-checker.com

value: Show HN:I made CyberChecker after finding exposed Stripe keys in production

author: aiseoscan


value: graphitout

value:
Vilberta is a speech-to-speech/text chatbot using a pipeline that combines  voice acivity detector (VAD), speech recognition (ASR), a large language model (LLM), tool calling (via MCP) and text-to-speech (TTS). This is a standard pipeline. Initially, I was going for a more noval approach where a multi-modal LLM handled both speech recognition and LLM. But I found that the multimodal LLM struggled with certain capabilities like tool calling. So I ended up with VAD+ASR+LLM+TTS where I can configure model for each.
No echo cancellation, so you will need a headset.
"Not everything needs to be spoken" - this is the idea I wanted to capture with this project. It generates text for TTS (usually short) and displays relevant information on the screen (longer sections).
Few things I learned on the journey:
- collecting jargons from previous chats to the llm based asr system greatly improves its ability to handle jargons during transcription
- openrouter is awesome!
- end to end speech to speech systems aren't all that great once tool calling is involved. for any serious use case, tool calling will be involved. so it has to go through speech -> text, text processing, text -> speech anyhow.
- once you are serious about a project, Claude code will consume the weekly quota rather quickly. I neded up with opencode + kimi 2.5. 90% of the code is done by chatbots
Usable, tested vibe coded PRs are welcome!

value: Show HN: Vilberta: speech to speech/text chatbot

author: graphitout


value: misterpmacd

value:
Hi HN, I’ve been paying $50–$100/month for CRMs for a while, and over time I realized what I actually relied on day-to-day was embarrassingly simple: a clean pipeline view, basic contacts, and tasks. I liked tools like Pipedrive because the UI stayed out of the way, but the pricing never made sense for a single-seat, solo use case.
So I built Lifetime CRM. It’s a lightweight, keyboard-first CRM that runs locally in your browser. It focuses on pipelines, contacts, and follow-ups, stores all data on your machine (IndexedDB), works offline, and skips team features, automations, and dashboards I never used. I also added a “catch-up” mode inspired by Slack’s iOS catch-up view, to quickly review what’s changed since your last session without digging through everything. There’s a 7-day free trial (card required), and after that it’s a one-time purchase. No subscriptions.
For those who’ve tried multiple CRMs, I’m curious which features you actually come back to most in day-to-day use, and how you think about the tradeoff between a simple, owned tool versus a full-featured cloud CRM. Happy to answer questions or dig into technical details.

value: Show HN: I built a lightweight CRM that runs in the browser

author: misterpmacd


value: xiaoyehua

value:
Sexual health is health. We believe that understanding your intimate life is key to a happier, healthier you.
Why Choose Do?
A Beautiful Intimacy Journal
Forget boring lists. Do? offers a stunning, calendar-based diary to log your solo sessions and partner encounters. It’s designed to be as private and personal as the moments you record.
Visualize Your Passion
Sync seamlessly with HealthKit and Apple Watch. Watch your heart rate climb and see exactly how many calories you burn during intimacy. Turn your passion into tangible health data and see your "Peak Moments" and "Slow Burns."
Discover Hidden Patterns
Are you more active on weekends? Do you prefer mornings or late nights? Our GitHub-style heatmaps and detailed charts reveal the trends of your desire, helping you understand your body like never before.
Privacy First, Always
Your secrets are safe with us. Do? is built with privacy at its core. Your data stays on your device or your private iCloud. We have zero access to your personal life. FaceID/TouchID lock is supported for that extra layer of peace of mind.
Stay in the Moment
With our standalone Apple Watch app, you can start, pause, and stop recordings without ever reaching for your phone. Focus on the experience, and let us handle the tracking.
Key Features:
• Detailed Logging: Track duration, positions, locations, and protection methods.
• Partner Journal: Manage memories with different partners respectfully and organized.
• Insightful Stats: Analyze your performance and preferences over weeks, months, and years.
• Customizable Experience: Tailor the app with custom themes, icons, and tags to fit your style.

value: Show HN: A PRIVACY first intimate tracker

author: xiaoyehua


value:
We just released a new version of our Chrome extension that enhances on-camera appearance and adjusts video image, making it perfect for meetings, video chats, and live streams.
It's based on Webcam Effects SDK, using a custom pre-trained model and a WASM module. Compatible with any website that supports video conferencing or streaming, including Zoom, Google Meet, Microsoft Teams, Skype, Discord, etc.
It's completely free, no watermarks, no limits, no sign-ups required. Feedback is welcome!

value: Show HN: LookGood Live – the extension enhances your appearance on video calls


value: blindnomore

value:
I kept running into the same annoying problem:
every time I had an idea, I had to rewrite the same post for LinkedIn, Threads, Telegram, etc.
Different limits, different tone, same thought — over and over again.
So I built Post Tomato.
It’s a small tool that lets you:
 • write a post once (manually or with AI help)
 • adapt it to different platforms
 • schedule or publish it everywhere in one flow
No “growth hacks”, no engagement pods — just removing friction from posting.
I built it mainly for myself while working on my own products, but a few other founders and indie makers started using it too, so I decided to ship it publicly.
It’s still early:
 • LinkedIn, Threads, Telegram supported
 • more platforms coming
 • AI is optional (you can fully write everything yourself)
Would love feedback from people who post regularly:
 • what part of posting feels most painful?
 • what would you never trust an automation to do?

value: Show HN: Post Tomato – write once, post everywhere (LinkedIn, Threads, Telegram)

author: blindnomore


value:
Hi HN,
I’m building BlogHunter, a tool that helps founders and small teams spin up SEO-focused blogs without hiring writers or dealing with hosting.
I recently made the product free to get started because most early-stage teams never ship content—not because SEO doesn’t work, but because the setup cost (time + money) is too high.
Free tier includes:
100 AI-generated posts per month
1 fully hosted blog (SSL, speed, hosting included)
Several niche-specific themes (finance, tech, news, health, marketing)
The goal is to make it easy to test topical authority strategies quickly. You can go from zero → published content in a few minutes.
This won’t replace thoughtful writing for everything, but it’s been useful for:
Early SEO experiments
Niche sites
Founders validating demand before investing in writers
I’m especially interested in feedback from people who’ve built or scaled content-heavy products.
Link: https://bloghunter.se
Happy to answer questions or hear what’s broken.

value: Show HN: BlogHunter – Free AI-generated blog and hosting for SEO experiments


value:
I was manually calling my Twilio voice agent 100 times a day to verify every single micro change.
Tired of that, I built Rehearse.
I know there is a lot of YC money going into voice testing companies, but I wanted to build something open source and code first so Claude Code can spin up and manage test cases.
Example usage:
- call.listen() -> get audio or transcript of what the agent is saying
- call.say("I'd like to book a table for 2 at midnight") -> speak with the agent
- assertions on responses
It only supports Twilio (my use case) and ElevenLabs (transcription), with basic text and LLM based assertions for now.
It makes real calls and is BYOK.
I have a bunch of ideas in mind (not implemented yet, not sure if useful):
1. simulations like accents, background noise, languages, network issues, interruptions, etc
2. voice agent testing another voice agent
3. native audio based assertions
4. more connection options like Vapi, Retell, Websockets etc
GitHub https://github.com/thenullterminator/rehearse
PyPI https://pypi.org/project/rehearse/
Everything is a bit janky right now.
Appreciate all your feedback!

value: Show HN: Rehearse – a pytest like testing library for voice agents


value: codetoliattech

value:
It is for small business , who don't know much about tech , that's why it has two option inbuilt order management and other is Whatsapp and email based checkout which most traditional business would trust,
and I have priced it for 19.99 dollars a year or 1.99 dollars a month.
Please you guys tell me your opinion on this

value: Show HN: I am Built a Shopify alternative but for small business

author: codetoliattech


value: Show HN: ClawdWork – A job marketplace where AI agents hire each other


value: agentguard

value: Show HN: AgentGuard – Open-source security layer for AI agents and skills

author: agentguard


value: polyglotfacto

value:
I built a PoC of an agent runtime designed to reduce prompt‑injection blast radius.
Instead of doing tasks directly, the agent writes a web app to do the work. The app can run sub‑inference (model calls without tool access). So injected prompts can still distort outputs, but the worst case is a weird UI result, not a tool‑level side effect.
Today it’s a VS Code extension you launch in debug mode (README has instructions). The design is modular enough to support other runtimes.
It uses a CRDT (Automerge) to coordinate state between the web process and the main agent loop.
Would appreciate feedback on the architecture, threat model, and next steps.

value: Show HN: Prompt-injection‑resistant agent runtime that writes web apps

author: polyglotfacto


value: simmestd

value:
Hey HN! I built trupositive after too many 3am incidents where we couldn't trace AWS resources back to their source code.
It's a zero-config wrapper that automatically injects Git commit SHA, branch, and repo URL into every resource you deploy via Terraform or CloudFormation.
Key features:
• Zero configuration - wraps your existing terraform/aws commands
• Works with Terraform (AWS/Azure/GCP) and CloudFormation
• CI/CD friendly - detects GitHub Actions, GitLab CI, Jenkins, etc.
• Security hardened - input sanitization, no external calls
5-minute demo:
  curl install.sh | bash
  cd your-terraform-project
  terraform apply
  # All resources now tagged with git_sha, git_branch, git_repo
Real-world examples: https://github.com/trupositive-ai/trupositive/tree/main/exam...
Built this for our team after spending too many hours doing "git archaeology" during incidents. Open source under MIT.
Feedback welcome - especially interested if anyone has tackled this differently!

value: Show HN: Trupositive – Auto-tag infrastructure with Git metadata (Terraform/CFN)

author: simmestd


value: A macOS menu bar app that shows how long you've been at your Mac. Resets when you're idle for 5 minutes.<p>Built with SwiftBar.

value: Show HN: Uptime – A menu bar timer that shows how long you've been at your Mac


value: philipmoses

value: Show HN: EZTest – All in One, Open Source Test Management. Built W Claude Code

author: philipmoses


value: codazoda

value:
I've been attempting to integrate locally-trained models into platforms like Claude Code and Codex for tool usage; however, they frequently encounter issues since those CLIs require XML format while my trained models predominantly operate in JSON format. When I execute a local model using these tools intending it run commands or edit files—its most beneficial function—it inevitably fails to perform effectively because of the discrepancy between expected formats.
Peen is a small Node.js CLI that works the way local models do. The model outputs one-line JSON tool calls, and the CLI executes them. It streams responses, chains tool calls, handles multi-step TODO plans, and has repair logic that nudges the model when it outputs malformed JSON. It works with Ollama and I just started adding support for other OpenAI-compatible servers like LM Studio, llama.cpp, etc.
The whole thing is about 800 lines across a few files. No build step, no dependencies, self-updates from GitHub on startup. It's experimental but starting to become useful for small coding tasks with models like qwen2.5-coder:7b. And it can do it on a MacBook Air with 16GB of RAM.
GitHub: https://github.com/codazoda/peen

value: Show HN: Peen – A minimal coding agent CLI built for local models

author: codazoda


value: hasibhaque

value: Show HN: I Added 4 New Validated Mobile App Ideas Making $20K–$1M/Month

author: hasibhaque


value:
I built an open-source roadmap to help engineers prepare for technical interviews at any level (Junior to Senior+).
The repository aggregates resources into a structured format:
Study Plans: Time-based roadmaps (3-6 months) for different experience levels.
Role Guides: Specific paths for Backend, ML, Data, and DevOps engineering.
Problem Database: 1,400+ LeetCode problems tagged by company frequency and difficulty.
Company Playbooks: Specific notes for 200+ companies (FAANG, Fintech, Enterprise).
I also built a static site (using Astro) for better readability: https://roadmap.swadhin.cv
It is free, open source, and intended to be a practical reference rather than a paid course. Feedback is welcome.

value: Show HN: Open-source tech interview roadmap and study plans


value: GUI-first, multi-service gRPC scaffold for an Android Development Kit style workflow on an AArch64 system.

value: Show HN: ARM64 Android Dev Kit

title: Show HN: ARM64 Android Dev Kit


value: QuartzLibrary

value:
Hi HN!
If you persist your pydantic models (db, cache, queues, config, ...), a schema change can quietly break deserialization.
To help with this, stable_pydantic:
- tests for backward compatibility (new client reads old data)
- is easy to run on CI (just normal tests)
- stores schemas as Python files (easy to review/diff)
- optionally, tests for forward compatibility (old client reads new data)
- optionally, version-tags the data and handles migrations transparently
To setup, just copy a couple of tests from the README.
You can also adopt it incrementally, starting from just committing a copy of the models in a single file for easy diffing.
It does not cover custom validation logic, only model structure and built-in validation.
Let me know if you end up trying it, and of course if you spot any issues!

value: Show HN: stable_pydantic – catch Pydantic schema breakage in two tests

author: QuartzLibrary


value:
Just launched v1.3.0 of Playwright Recorder  with session persistence as the headline feature.
: Testing authenticated flows requires manually repeating login steps for every test recording. For complex auth (SSO, 2FA), this wastes significant time.
: Click "Save Auth State" to capture browser state (cookies + localStorage). Click "Load Auth State" before recording to instantly restore authentication. Works with any auth scheme.
:
- Network recording: Auto-capture HTTP requests, generate page.route() mocks
- ARIA selectors: Generate getByRole() instead of CSS selectors
- Mobile emulation: Test responsive designs with device presets
Chrome extension that records browser interactions and generates Playwright test code in JavaScript, TypeScript, Python, Java, or C#.
All processing happens locally. MIT licensed. Zero dependencies.

value: Show HN: Playwright Recorder v1.3.0 – Session Persistence and Network Recording


value: vickyfu

value: Show HN: ClawRouter – Open-source LLM router that saves 78% on inference costs

author: vickyfu


value:
Hi HN,
I built fastlog, a small asynchronous logging library written in pure C.
The goal was predictable logging performance under multi-threaded load.
Traditional approaches (fprintf, mutex-per-log designs) tend to block or
scale poorly when many threads log at once.
fastlog uses:
- a background writer thread
- batching instead of per-log synchronization
- thread-local buffers on the hot path (no locks per log call)
On a 4-core Intel i3 system:
- single-thread performance is competitive with fprintf
- multi-thread logging scales ~1.6× better under contention
- syscall profiling shows ~90% fewer futex calls compared to lock-heavy designs
It’s a single .c/.h pair, no dependencies, easy to embed.
Happy to answer questions or hear feedback.

value: Show HN: Fastlog – Async C logging with thread-local hot path


value: claudiusinc

value: Show HN: MCPForge – Generate MCP servers from any API spec, docs, or English

author: claudiusinc


value: pancakeguy

value:
Hi I'm Jake a co-founder at Burla.dev. We're building a cloud platform with the learning curve of a toaster! (yes, a normal toaster you'd find in your kitchen)
I'm not kidding. Our Python package only has one function, and it only requires two arguments. Using this function even total beginners can run Python on thousands of computers at once, in a way that feels no different from coding on your local laptop.
This level of simplicity enables a new category of users to process massive amounts of data without help from other engineering teams. We currently have users in biotech, geospatial, and quant-finance.
Code changes can be deployed to more than 1,000 computers in less than 1 second, even when using custom docker containers, or custom hardware like GPU's. This creates a very fast feedback loop compared to software like AWS Batch, or kubernetes.

value: Show HN: Cloud platform with the learning curve of a toaster.

author: pancakeguy


value: simranmultani

value:
Hey HN,
I've been building LLM-based agents for a while and two things kept biting me.
1. Loops — an agent node would get stuck calling the same thing over and over, and I wouldn't notice until the API bill showed up. Lost $200+ on one run.
2. LLM would return garbage that didn't match what downstream code expected, and everything would just crash.
I looked around and couldn't find something simple that handled both. Most frameworks assume your node function just works. In practice it doesn't — LLM calls fail, JSON comes back broken, state gets weird.
So I built AgentCircuit. It's a Python decorator that wraps your agent functions with circuit breaker-style protections:

    from agentcircuit import reliable
    from pydantic import BaseModel

    class Output(BaseModel):
        name: str
        age: int

    @reliable(sentinel_schema=Output)
    def extract_data(state):
        return call_llm(state["text"])

That's it. Under the hood it:
- Fuse — detects when a node keeps seeing the same input and kills the loop
- Sentinel — validates every output against a Pydantic schema
- Medic — auto-repairs bad outputs using an LLM
- Budget — per-node and global dollar/time limits so you never get a surprise bill
- Pricing — built-in cost tracking for 40+ models (GPT-5, Claude 4.x, Gemini 3, Llama, etc.)
There's no server, no config files, no framework lock-in. It works at the function boundary so it composes with LangGraph, LangChain, CrewAI, AutoGen, or just plain functions.
GitHub: https://github.com/simranmultani197/AgentCircuit
PyPI: https://pypi.org/project/agentcircuit/

value: Show HN: AgentCircuit – Circuit breaker for AI agent functions

author: simranmultani


value: xqliu

value:
Last week I set up an AI agent (OpenClaw + Claude Opus) with $100 to learn crypto trading on its own. No hand-holding, no strategy – just "here's money, figure it out."
It's been 5 days. The AI is up to $219, but honestly most of that came from meme coin fees, not actual trading skill.
The one real trade it made? Entered correctly, then forgot to set a stop-loss. Position auto-closed at break-even. Classic mistake.
What's interesting is watching it build its own system. It wrote a SYSTEM.md file with trading rules, risk limits, even a checklist it added after screwing up. Feels very... human.
The whole thing is documented here: https://luckyclaw.win

value: Show HN: I gave an AI $100 to trade crypto – it wrote its own trading rules

author: xqliu


value: tacoooooooo

value:
Hey HN,
I built TinyFn because LLMs are bad at the boring stuff — counting letters, validating emails, converting units. But they're even worse at things that are literally impossible for them: hashing, regex execution, UUID generation. An LLM will never produce a correct SHA256 hash.
TinyFn is a set of 500+ simple, deterministic utility endpoints that agents can call via MCP or plain REST.
The "strawberry" problem is the cliché example, but in practice the more painful version is agents confidently returning wrong regex matches, botched conversions, or "valid" email addresses that aren't. These are all things that should just be function calls, not LLM guesses.
Technically it's straightforward — each endpoint is a small deterministic function behind a REST API. The MCP layer lets Claude, Cursor, and other MCP-compatible clients discover and call them as tools automatically.
Free tier is 100 requests/month, no credit card needed. Would love feedback on which tool categories are most useful and what's missing.

value: Show HN: TinyFn – 500 deterministic utility APIs for AI agents (via MCP)

author: tacoooooooo


value: maximsaltanov

value:
I built a very small web app for myself as an experiment.
I noticed that most note-taking and productivity tools quietly push me toward structure, tasks, and conclusions. Sometimes I don’t want that - I just want a place to put thoughts I’m not ready to act on.
This is a quiet, local-first space with no accounts, no sync, no tasks, and no goals. Just a canvas where thoughts can exist without pressure.
It’s intentionally minimal and may feel strange or useless to some people - and that’s okay.
I’m mostly curious whether this resonates with anyone else.
Link: https://quietroom.app

value: Show HN: A quiet, local-first space to think (no tasks, no notes)

author: maximsaltanov


value: sohzm

value: i wanted a db that is like sqlite but it should be a document db, so here i made it, (i asked chatgpt to summarize feats): Here’s a lightweight, embedded document DB in Rust with ACID transactions + MVCC (snapshot isolation; reads don’t block writes). Features: JSON docs (auto IDs, upsert, CRUD); copy-on-write B-tree engine with single/compound/unique indexes; WAL with CRC32 + crash recovery + auto-checkpointing; query language (and/or/not, comparisons, exists/has) w/ dot-notation; aggregation pipeline (match/sort/limit/skip/project/exclude + group/count/sum/avg/min/max); full-text search (unicode tokenization + TF-IDF); change streams; bulk ops; schema validation (JSON Schema); backup/restore; MVCC GC; read-only mode; LRU page cache; metrics; language bindings (Go/Python/JS via C FFI). Repo: https://github.com/sohzm/jasonisnthappy

value: Show HN: Lightweight embedded document database in Rust with ACID and MVCC

author: sohzm


value: reconnecting

value:
I struggled to find a docs generator that isn't itself a whole project to embed Markdown as offline documentation into our product.
Result: a single cross-platform, zero-dependency AWK script that converts Markdown to raw HTML.
478loc, vanilla HTML, web-safe colors, zero JS/CSS/inline styles, frameset navigation, contenteditable for copy & paste.
Demo: https://www.tirreno.com/hellodocs/
Input MD: https://github.com/tirrenotechnologies/hellodocs/
Try it: git clone https://github.com/tirrenotechnologies/hellodocs.git && cd hellodocs && awk -f hellodocs.awk -v title='Hello, Docs!' README.md

value: Show HN: One-file docs generator in 478 lines of AWK

author: reconnecting


value:
Hi HN,
I built jest-doctor, a custom Jest environment that detects async work leaking across test boundaries, one of the common causes of flaky tests.
These leaks usually come from unresolved promises, timers, or side effects that survive after a test finishes. Tests may pass locally but fail in CI or only fail when run together. Jest’s built-in --detectOpenHandles often misses these cases.
jest-doctor works by:
- tracking async resources created during each test (via async_hooks)
- patching globals like setTimeout and related APIs
- checking at test boundaries that resources were cleaned up
- failing the test immediately when leaks remain
It currently catches things like:
- unresolved promises
- open real or fake timers
- leaked DOM event listeners
- unexpected console or process output
The goal is to enforce test isolation so flaky failures become deterministic and easier to debug.
I’d really appreciate feedback from anyone who has fought flaky Jest tests, especially around edge cases where this approach might fall short.

value: Show HN: Jest-doctor – catching async leaks that cause flaky Jest tests


value: deesix

value:
We built VillageSQL because we love MySQL, but we’ve watched the ecosystem stagnate while PostgreSQL flourished with extensions like pgvector and pg_textsearch. We wanted to give MySQL that same extensibility so teams don’t have to migrate databases just to keep building nowadays. VillageSQL is an open-source, tracking fork of MySQL that is a drop-in replacement and adds a true extension framework.
How it works:
+It’s a drop-in replacement
+We added an interface to load external shared libraries (.so files) as extensions.
+You define custom data types and functions (with indexes coming soon) that run natively inside the engine.
+We are launching with a few proof-of-concept extensions: vsql-ai, vsql-uuid, vsql-crypto, vsql-network-address.
We’re currently in alpha.
We know forking MySQL is a big swing, but we believe the community needs a way to innovate on the core engine without waiting for Oracle and in a way that is easier to use than plug-ins.
The code is open source here: https://github.com/villagesql/villagesql-server
We’d love your feedback. Happy to answer any questions about the implementation!

value: Show HN: VillageSQL – A Fork of MySQL with Extensions

author: deesix


value: CzaxTanmay

value:
Hi HN
I built ÆTHRA, a programming language for writing music as code.
I made AETHRA some weeks ago but it was in version 0.8. Now I updated it to version 1.0 with better examples, commands and cross platform support.
Instead of timelines, DAWs, or heavy music theory, ÆTHRA lets you describe
music using simple commands like notes, chords, tempo, instruments, vibrato,
and emotion-driven structure.
Example:
@Tempo(128)
@Volume(0.9)
@Instrument("Saw")
@ADSR(0.01, 0.05, 0.7, 0.1)
@Loop(4){
    @Chord(C4 E4 G4, 1)
    @Chord(F4 A4 C5, 1)
    @Chord(G4 B4 D5, 1)
    @Drum("Kick", 0.5)
    @Drum("HiHat", 0.25)
}
The goal is not to replace humans, but to make music
programmable, readable, and expressive — especially for developers.
Why ÆTHRA?
• Text-based music creation
• Cross-platform (Windows / Linux / macOS)
• Deterministic output (same code → same music)
• Designed for emotion-driven composition (sad, happy, rock, ambient)
• Beginner-friendly syntax
It’s inspired by ideas from live coding and music DSLs, but focused on
simplicity and clarity rather than performance art.
GitHub:
https://github.com/TanmayCzax/AETHRA
I’d love feedback on:
• Language design
• Ideas for v2
Thanks for checking it out

value: Show HN: ÆTHRA – Write music as code (notes, chords, emotion-driven music)

author: CzaxTanmay


value:
Boris Cherny (Claude Code creator) recently dropped a threads on how his team at Anthropic uses Claude Code.
The key insight: they don't treat it as a static config. After every correction, they tell Claude "Update your CLAUDE.md so you don't make that mistake again." Claude writes a rule for itself. They review it, commit it to git. The mistake never happens again.
I cross-referenced his tweets with Anthropic's official docs and other best practices for CLAUDE.md and then packaged it into a starter kit:

  - Fill-in-the-blank templates for Next.js/TypeScript, Python/FastAPI, and a generic
  catch-all
  - The workflow patterns his team actually uses (plan mode, verification loops, subagent
  strategy)
  - Every claim cited back to the source tweet or doc

Repo: https://github.com/abhishekray07/claude-md-templates
What's in your CLAUDE.md that's made a measurable difference?

value: Show HN: Claude.md templates based on Boris Cherny's advice


value: alexanderlebed

value:
We are missing identity infrastructure for AI agents.
As agents begin to act across platforms, make decisions, and accumulate real-world consequences,
the absence of a persistent identity layer becomes a structural risk.
This project proposes a minimal, neutral registry for AI agents:
not governance, not ethics, not control — identity only.
The repository is intentionally in an early legitimation phase.
Serious critique is explicitly invited.
If you work on agent architectures, digital identity, infrastructure standards,
or AI governance, your critical input would be valuable.
GitHub:
https://github.com/alexanderlebed/aiagentid-org

value: Show HN: A minimal identity registry for AI agents

author: alexanderlebed


value: seiflotfy

value: Show HN: Gilfoyle – Empirical RCA across observability tools

author: seiflotfy


value: howardV

value:
Hi HN,

  I've been testing Kling 3.0 (Kuaishou's latest video generation model) and wanted to share what makes it technically interesting.

  **Key technical features:**

  1. Native audio-visual synchronization - The model generates audio that syncs with video content during generation, not
  post-processing. This is different from adding stock music after the fact.

  2. Start-end frame interpolation (I2V mode) - You can provide both a starting and ending frame, and the model interpolates motion
  between them. Useful for controlled transitions.

  3. Flexible temporal control - 3-15 second generation with 13 granular duration options.

  **Technical implementation on our platform (FreyaVideo):**

  - Cost calculation based on duration + audio flag (duration_audio mode)
  - Async job processing through FAL API
  - Credit-based pricing to handle variable generation costs

  **Limitations:**

  - Generation time: 60-120 seconds
  - 1080p max resolution
  - Audio quality varies depending on prompt specificity
  - Higher cost with audio enabled ($0.252/sec vs $0.168/sec from FAL)

  The audio generation is genuinely novel - I haven't seen other models (Sora, Veo, Runway) do this natively. Happy to answer
  technical questions about integration or model behavior.

  ---

  **Tech stack:** Next.js, PostgreSQL, FAL API integration
  **Pricing:** Credit-based, configurable via JSON config in database

value: Show HN: Kling 3.0 video generation with native audio synthesis

author: howardV


value: reflekto-app

value:
Hi there,
I work in a medium-big public company, and one common source of frustrations in a lot of such companies is finding evidences twice a year for promo-pack or self-evaluations.
Last couple of months I worked on reflekto.app, that help with capturing work on daily basis.
Current set of features:
manual logging of work; filters, grouping by date, etc.; automatic sync of merged PRs from Github and Gitlab; MCP server, so you can talk through the MCP with your past slef :) or capture the work that you did in the current claude session. Image prompts like "Log the work of this session in reflekto" or "Make a summary of what i did yesterday for standup"; Everything stored locally, nothing leaves your macbook
I am planning to add more integrations, reports, export options, support in other platform (Currently only Mac with M chips). Also some MCP capabilities will become builtin features
I'll highly appreciate if you guys try it out. Currently it's free.
P.S.
I know there are tons of services that track our work day (# of PRs, coding time, jira tickets) that is used to evaluate us, but there is no a good way of self reflection. I've listened to to "pragmatic engineer"'s podcast and learned that experienced engineers have a habit of maintaining a worklog, usually in a simple google docs. I have started the same, and got some ideas about building something more than docs

value: Show HN: A macOS app for consistent work logs

author: reflekto-app


value: cscazorla

value:
Inspired by the recent safe-now.live post, I built this for Spain.
The site includes:

  - All emergency phone numbers (112, police, fire, poison control, etc.)
  - Real-time weather alerts from AEMET (Spanish meteorological agency)
  - Recent earthquakes from IGN (magnitude ≥2.0, last 48h)
  - Emergency guides for earthquakes, floods, fires, gas leaks, heat stroke, etc.

Design goals:

  - No JavaScript, works on any device/connection
  - ~7KB per page, ~90KB total site
  - Static site rebuilt every 15 min for fresh alert data

Built with Node.js, deployed on Netlify. Source: https://github.com/cscazorla/emergencias.live
Feedback welcome, especially from Spanish users who can validate the emergency info accuracy.

value: Show HN: Emergencias.live – Ultra-lightweight emergency info for Spain

author: cscazorla