Show HN за 30 мая 2026 г.

I built a terminal app that paces slow breathing at 6 breaths per minute for vagal tone training. It's a single Python file, stdlib only, no dependencies — just run breathe and follow the bar.

I'm a cardiology patient (HFrEF). Slow breathing at resonance frequency is one of the few non-pharmacological interventions shown to improve cardiac vagal tone and baroreflex sensitivity (Bernardi et al., Circulation 2002; Lancet 1998). I wanted a frictionless daily habit tool — no app store, no account, no subscription, just open terminal and go.

Design constraints, all grounded in the clinical literature:

- No breath retention — Valsalva risk in cardiac patients

- No rapid breathing — minimum 8-second cycles

- Exhale ≤ 2x inhale — no evidence for extreme ratios

- Immediate exit, always — q or Ctrl+C restores the terminal even on crash

The README includes a resonance frequency measurement protocol for anyone with a chest-strap HRV monitor who wants to find their individual optimum instead of using the 6 bpm default.

macOS only (uses afplay for audio cues). MIT licensed. pip install breathe-cli or brew tap marekkowalczyk/breathe && brew install breathe.

Plug-in solar panels (no electrician needed) have just become legal in the UK and will go on sale soon. Helios estimates how much electricity a typical installation could generate at a given address and what that's worth against your tariff.

It uses UK government LIDAR data to reflect the actual skyline, so it knows whether there's a building or a hill blocking the sun.

Caveats: - Outside LIDAR coverage (most of Scotland and Wales) it falls back to a synthetic horizon (less accurate). - Trees and recent developments (post-2022 or so) may not be in the data, and some address placements could be off (geocoding via OSM).

Feedback on the shading model especially welcome.

In 2025, my family and I had a long streak of playing a Gomoku / Go Bang / five-in-a-row based game called OK Play. I built a web version so that we could play any time we wanted (i.e. on our phones after kiddos went to sleep).

The first player to get five-in-a-row (horizontally, vertically, or diagonally) wins. In the first phase of play, players take turns placing their pieces next to existing pieces (always edge-to-edge; you can't place a piece with only a corner-to-corner connection). After players exhaust their pieces, play moves into the movement phase: you pick up an existing piece you own and place it according to the previous placement rules. During the movement phase, you cannot move a piece that would leave other pieces disconnected. Play continues in player order until someone wins.

I wrote the app using Elixir's Phoenix framework with Daisy UI / Tailwind CSS for styling. The app is deployed on Gigalixir via its generous free plan. I am by no means a frontend developer / designer, so there's for sure better ways to implement things than what I have here. I mostly focused on making it mobile friendly and getting it to support light and dark mode. There likely exists browser / device specific bugs, since we've only tested it out on our phones (iPhone 13 Pro, Safari / Chrome) and my computer (MacBook Pro, Safari). Happy to hear any suggestions, frontend or otherwise, if you have them!

Developing this has been a real journey. Highlights have included learning about Gomoku and its variants, articulation points (and Trajan's algorithm for strongly connected components), and the Monte Carlo tree search algorithm (for the intermediate level "AI" mode I've recently added for single-player use). Lowlights have all been CSS related.

I'd love to add a "matchmaking" mode in the future. I haven't really looked too much into the mechanics for how that's usually done though - it'll be a great learning opportunity!

We built this Dockerfile because we wanted a simple harness server to run our agents and get memory, durable sessions, cron scheduling, and a vault, out of the box.

Babo script is source code written in plain English. LLM compiler reads the description, builds a runnable program and runs it.

Not a dev tool, just scripting tool.

TL;DR: Jynx is a gaming social platform that matches you with compatible teammates based on skill level, play style and schedule. Swipe to find players (Tinder-style), create or join game sessions (LFG), chat, and build your squad. 214k lines of Dart, 23 feature modules, built entirely with Claude Code as my entry into agentic engineering.

Live on App Store and Play Store: https://play.google.com/store/apps/details?id=app.jynx https://apps.apple.com/fr/app/jynx-where-gaming-gets-social/...

---

Hi HN, long time lurker, first time poster, be gentle.

Developer by day, vibe coder by night: Jynx is the project I used to ease into agentic engineering.

AI talks are mitigated, at best. But I'll talk about my experience here. Forgive my erratic style, it is what it is.

Working with Claude from the very beginning, it's been a blast. I had the "chance" to have the time necessary to learn and use AI a lot. Lots of different techniques that quickly became completely obsolete today.

Without LLMs, it would have been extremely hard to have the same app than I have today. I used Flutter (Dart) to avoid having to dev and maintain two codebases. It is not a language I knew. Learning the language first would have severely hindered the process.

For me, from copy/paste to using MCP then Roo Code, then Claude Code was an ecstatic process. I always loved having ideas but the time it would take me to build the thing and test it always felt too long. Not anymore.

So we carefully designed, iterated and implemented the two codebases for Jynx. One for the flutter app, one for the firebase backend. I chose Firebase to avoid having to maintain a server and be able to focus on the UI/UX of the app.

We started thinking about it in December 2024 and started devs early 2025; not working on it full time at all. We really poured our heart into it and we truly tried to make it as secure as possible. Even though we mean business, it is a passion project. By using the excuse of learning agentic flows, I took the time to inspect each aspects of the app's systems thoroughly.

Tech stack: - Flutter 3.41 / Dart 3.11 (single codebase, iOS + Android) - Firebase (Firestore, Cloud Functions in TypeScript, Auth, Storage, FCM) - Riverpod 3.1 + Freezed + json_serializable for state management & immutable models - Drift for encrypted local SQLite caching (offline-first architecture to optimize Firebase costs) - Clean Architecture with feature modules and mixin-based repositories - Sentry + Firebase Crashlytics for production error reporting - Freerasp for runtime app self-protection (tamper detection, root/jailbreak)

Agentic engineering artifacts: - Claude Code (Claude + GLM) as primary coding agent - 22 hooks, 18 skills, 13 instincts, 8 rule files, custom subagents, slash commands, MCP servers and plugins (instincts system from Affaan's https://github.com/affaan-m/everything-claude-code) - GitNexus - MemPalace for persistent context across sessions

Stats: 1,239 Dart files, 214k lines of code (excluding generated boilerplate), 30k lines of comments across the Flutter codebase.

I made a detailed cheatsheet document about my whole setup if you want it. I could post it or you DM me.

If you have questions, ask away, I'll gladly answer.

Test it and tell me what you think of it honestly, I won't get offended!

Take care, Antoine

developed AI-Simulaion wihout LLM including simulated neurochemistry, hormon crosstalking, short and long term memoryfor each agent. open beta starting Monday at 20:00 UTC+2

for more informations https://www.reddit.com/r/ArtificialInteligence/comments/1tnl...

Hi HN,

About a month ago, I shared leaf here while it was still in its early stages.

Since then, the project has shipped multiple releases, with UX improvements, bug fixes, and a documentation website now available.

leaf is a terminal-based Markdown reader focused on a GUI-like experience, with navigation, search, table of contents, clickable links, syntax highlighting, editor integration, LaTeX rendering, Mermaid diagrams, and more.

It works on Linux, macOS, Windows, and Termux.

GitHub: https://github.com/RivoLink/leaf

Thanks to all contributors and everyone who starred the project for their support, and feedback on UX, performance with large files, and missing features is still very welcome.

Based on Naur's "Programming as Theory Building" (1985) Asks agent to create a problem-theory artifact before writing code.

I built thaw because forking an LLM agent is absurdly wasteful today. When an agent explores N branches — RL rollouts, best-of-N, parallel coding attempts — each branch re-runs prefill over the same shared context. You pay for the same prompt N times.

thaw snapshots a live inference session — weights, KV cache, scheduler state, and the prefix-hash table — and hydrates N children that diverge from the fork point without re-prefilling. It's `git branch` for a running model.

The receipt (H100 80GB, Llama-3.1-8B, real hardware): a pre-warmed pool boots once in 22.3s, then each fork round of 4 branches × 64 tokens runs in 0.88s median. Cold-boot equivalent would be ~340s/round — ~400× amortized. All rounds bit-identical at the fork boundary. Full JSON receipt + reproducer in the repo, nothing hand-waved.

NVIDIA shipped Dynamo Snapshot last week for fast pod cold-starts — and they free the KV cache before checkpoint, by design. thaw is the opposite bet: preserve the KV cache so a fork is near-free. Different problem, opposite mechanic.

pip install thaw-vllm. Works with vLLM and SGLang, Apache-2.0.

https://github.com/thaw-ai/thaw

I'm a solo dev and this is the thing I most want feedback on: is the fork primitive the right shape, or do people want it wrapped in a framework(LangGraph/TRL) node instead? Happy to go deep on the KV-restore internals.