Show stories

I've worked in tech my entire career, and over time mindfulness meditation has become less of a "wellness habit" and more of a practical tool for keeping my mind clear.

I encourage mindfulness meditation to everyone because it's that impactful on stress and awareness in everyday life.

After years of practice, I've that most meditation apps eventually became distracting or costly.

To me, mindfulness apps that provide guidance, content, forced streaks, and incentives seem to replace the practice of mindfulness itself with some gamification of the act.

So I built Center, a silent meditation timer with a few constraints:

• No guided sessions, voices, or music • No subscriptions, ads, or paywall • Optional tracking, no gamification • Works across iPhone, Apple Watch, iPad, and Mac via iCloud • Donation-supported, with no features locked

The goal has never been growth or engagement, but reliability. I wanted something closer to a clock than a coach.

This is a side project, but it’s been interesting to see how a deliberately "boring" tool changes how I personally practice mindfulness, and how that carries over into my work (especially decision-making and stress tolerance).

Site: https://centertimer.com

The article discusses the Cargo Rail project, an open-source platform that allows users to create and manage their own decentralized file storage networks. It highlights the project's key features, such as enabling individuals to host and monetize their spare storage capacity, and providing a user-friendly interface for setting up and managing these networks.

I've been building side projects for over a decade. Most failed to find Product‑Market‑Fit - I know the frustration of shipping features that don't stick.

The painful truth I learned: many teams chase features over feedback. Worse, most feedback is shallow or useless because people avoid being critical.

So I built user.mom to fix the process, not just add another tool. It maps the full PMF journey: Landing Pages to validate demand, Surveys to gather structured signals, Feedback Boards to organize requests, Customer Voting to prioritize, and Integrations (CSV, webhooks, API) to scale what works.

If you’re tired of guessing what customers want, start your PMF workflow - the first product is free for every user.

Tambourine is an open source, fully customizable voice dictation system that lets you control STT/ASR, LLM formatting, and prompts for inserting clean text into any app.

I have been building this on the side for a few weeks. What motivated it was wanting a customizable version of Wispr Flow where I could fully control the models, formatting, and behavior of the system, rather than relying on a black box.

Tambourine is built directly on top of Pipecat and relies on its modular voice agent framework. The back end is a local Python server that uses Pipecat to stitch together STT and LLM models into a single pipeline. This modularity is what makes it easy to swap providers, experiment with different setups, and maintain fine-grained control over the voice AI.

I shared an early version with friends and recently presented it at my local Claude Code meetup. The response was overwhelmingly positive, and I was encouraged to share it more widely.

The desktop app is built with Tauri. The front end is written in TypeScript, while the Tauri layer uses Rust to handle low level system integration. This enables the registration of global hotkeys, management of audio devices, and reliable text input at the cursor on both Windows and macOS.

At a high level, Tambourine gives you a universal voice interface across your OS. You press a global hotkey, speak, and formatted text is typed directly at your cursor. It works across emails, documents, chat apps, code editors, and terminals.

Under the hood, audio is streamed from the TypeScript front end to the Python server via WebRTC. The server runs real-time transcription with a configurable STT provider, then passes the transcript through an LLM that removes filler words, adds punctuation, and applies custom formatting rules and a personal dictionary. STT and LLM providers, as well as prompts, can be switched without restarting the app.

The project is still under active development. I am working through edge cases and refining the UX, and there will likely be breaking changes, but most core functionality already works well and has become part of my daily workflow.

I would really appreciate feedback, especially from anyone interested in the future of voice as an interface.

I built depup, a CLI tool to scan Python dependencies, check PyPI versions, classify upgrade impact, and support CI workflows.

Docs: https://saran-damm.github.io/depup/ Repo: https://github.com/saran-damm/depup/

The article discusses the creation of a tool called 'llmwalk' that allows users to interact with large language models (LLMs) through a command-line interface, enabling them to explore the capabilities of these models in a more accessible and transparent way.

PhotoToVideoAI is an AI-powered tool that turns your photos into dynamic videos. Upload a photo and a prompt, and in about 30 seconds you'll get a high-quality video in resolutions up to 1080p and durations of 5 or 10 seconds. It’s designed for content creators, marketers, and photographers, Feedback is welcome!

I built Read Fast after realising I was saving hundreds of things to read and reading almost none of them.

It automatically turns saved content into a scheduled briefing and sends it to my inbox at whatever time I choose.

New version since last post actually allows you to bulk upload URLs. So you can just dump links here and Read Fast will scrape and brief for you.

Great for actually reading the things I want to. Curious if that resonates with people?

Hello HN! I'm happy to release this project today. It's a bidirectional calculator (hence the name bidicalc).

I've been obsessed with the idea of making a spreadsheet where you can update both inputs and outputs, instead of regular spreadsheets where you can only update inputs.

Please let me know what you think! Especially if you find bugs or good example use cases.

The article describes the UVM32, an open-source, 32-bit RISC-V processor designed for educational and research purposes. It provides a flexible and customizable hardware platform for exploring computer architecture and processor design.

LinkedQL is a new SQL client that supports live queries over any Postgres, MySQL, and MariaDB database. You get result sets that self-update differentially as rows change in your database – via inserts, updates, deletes. Works with no extra tooling/ORM layer or GraphQL servers. You opt into live mode simply with a flag: client.query('SELECT ...', { live: true }). More at: https://linked-ql.netlify.app/capabilities/live-queries

LinkedQL is written in JavaScript and runs in both client and server environments.

GitHub + docs: https://github.com/linked-db/linked-ql

Demo examples included.

I’d love feedback: • Anything confusing? • Anything seems useful or dangerous? • Anything else that'd make you consider LinkedQL for production?

Thanks for taking a look — happy to answer any questions.

The article introduces a Critical CSS Generator tool that automatically extracts and inlines the critical CSS for a given web page, helping to optimize performance and load times by prioritizing the most essential styles.

If you have heard of [Haven](https://github.com/guardianproject/haven), then Tripwire fills in the void for a robust anti evil maid solution after Haven went dormant.

The GitHub repo describes both the concept and the setup process in great details. For a quick overview, read up to the demo video.

There is also a presentation of Tripwire available on the Counter Surveil podcast: https://www.youtube.com/watch?v=s-wPrOTm5qo

OP here.

I built this because I recently caught myself almost pasting a block of logs containing AWS keys into Claude.

The Problem: I need the reasoning capabilities of cloud models (GPT/Claude/Gemini), but I can't trust myself not to accidentally leak PII or secrets.

The Solution: A Chrome extension that acts as a local middleware. It intercepts the prompt and runs a local BERT model (via a Python FastAPI backend) to scrub names, emails, and keys before the request leaves the browser.

A few notes up front (to set expectations clearly):

Everything runs 100% locally. Regex detection happens in the extension itself. Advanced detection (NER) uses a small transformer model running on localhost via FastAPI.

No data is ever sent to a server. You can verify this in the code + DevTools network panel.

This is an early prototype. There will be rough edges. I’m looking for feedback on UX, detection quality, and whether the local-agent approach makes sense.

Tech Stack: Manifest V3 Chrome Extension Python FastAPI (Localhost) HuggingFace dslim/bert-base-NER Roadmap / Request for Feedback: Right now, the Python backend adds some friction. I received feedback on Reddit yesterday suggesting I port the inference to transformer.js to run entirely in-browser via WASM.

I decided to ship v1 with the Python backend for stability, but I'm actively looking into the ONNX/WASM route for v2 to remove the local server dependency. If anyone has experience running NER models via transformer.js in a Service Worker, I’d love to hear about the performance vs native Python.

Repo is MIT licensed.

Very open to ideas suggestions or alternative approaches.

UnisonDB is a distributed, fault-tolerant, and versioned database that provides a unified API for structured and unstructured data. It aims to simplify the development of distributed applications by offering a scalable and reliable data storage solution with built-in support for version control, replication, and offline access.

CodeAnswr is a website that provides a platform for developers to ask and answer questions, share code, and collaborate on projects. The site offers a community-driven approach to problem-solving and knowledge sharing in the software development field.

This article explores the science behind coin flipping, discussing the physics involved, factors that can influence the outcome, and the inherent randomness of this common method of making decisions.

The biggest problem with Tic-Tac-Toe is that it almost always ends in a draw. Tic Tac Flip tries to fix that!

Learn the rules in Learning Mode or below:

- Winning Criteria: 3 Ghosts (Flipped O or X, which can be a mixture). It's not just 3 Os or 3 Xs anymore!

- Flipping Mechanic: When one or more lines having only O and X are formed, the minority of either all Os or all Xs get flipped to a Ghost, and the majority gets removed from the board. E.g., A line of 2 Os and 1 X leads to 1 X ghost and the removal of 2 Os.

- Active Flip: You can actively flip your O/X to a Ghost (or flip a ghost back) once per game.

- Placing Ghost Directly: You can place a "Ghost" piece directly as a final winning move (only once, and only when there are two existing ghosts in a line).

I'm looking for feedback on the game balance and learning curve. Specifically: - Is the "Ghost" and "Flip" mechanic intuitive? - Is the Learning Mode helpful? - Is the game fair? Any rule adjustments needed? - Any bugs or issues?

Any suggestions or comments would be much appreciated. Thank you in advance!

The article discusses the future of news consumption in 2035, predicting a shift towards more personalized, interactive, and immersive news experiences driven by advancements in technology and user preferences.

Hey HN, Waleed here. We're building Sim (https://sim.ai/), an open-source visual editor to build agentic workflows. Repo here: https://github.com/simstudioai/sim/. Docs here: https://docs.sim.ai.

You can run Sim locally using Docker, with no execution limits or other restrictions.

We started building Sim almost a year ago after repeatedly troubleshooting why our agents failed in production. Code-first frameworks felt hard to debug because of implicit control flow, and workflow platforms added more overhead than they removed. We wanted granular control and easy observability without piecing everything together ourselves.

We launched Sim [1][2] as a drag-and-drop canvas around 6 months ago. Since then, we've added:

- 138 blocks: Slack, GitHub, Linear, Notion, Supabase, SSH, TTS, SFTP, MongoDB, S3, Pinecone, ...

- Tool calling with granular control: forced, auto

- Agent memory: conversation memory with sliding window support (by last n messages or tokens)

- Trace spans: detailed logging and observability for nested workflows and tool calling

- Native RAG: upload documents, we chunk, embed with pgvector, and expose vector search to agents

- Workflow deployment versioning with rollbacks

- MCP support, Human-in-the-loop block

- Copilot to build workflows using natural language (just shipped a new version that also acts as a superagent and can call into any of your connected services directly, not just build workflows)

Under the hood, the workflow is a DAG with concurrent execution by default. Nodes run as soon as their dependencies (upstream blocks) are satisfied. Loops (for, forEach, while, do-while) and parallel fan-out/join are also first-class primitives.

Agent blocks are pass-through to the provider. You pick your model (OpenAI, Anthropic, Gemini, Ollama, vLLM), and and we pass through prompts, tools, and response format directly to the provider API. We normalize response shapes for block interoperability, but we're not adding layers that obscure what's happening.

We're currently working on our own MCP server and the ability to deploy workflows as MCP servers. Would love to hear your thoughts and where we should take it next :)

[1] https://news.ycombinator.com/item?id=43823096

[2] https://news.ycombinator.com/item?id=44052766

Hi there, HN! We’re Jai and Sanket from DeepSource (YC W20), and today we’re launching Autofix Bot, a hybrid static analysis + AI agent purpose-built for in-the-loop use with AI coding agents.

AI coding agents have made code generation nearly free, and they’ve shifted the bottleneck to code review. Static-only analysis with a fixed set of checkers isn’t enough. LLM-only review has several limitations: non-deterministic across runs, low recall on security issues, expensive at scale, and a tendency to get ‘distracted’.

We spent the last 6 years building a deterministic, static-analysis-only code review product. Earlier this year, we started thinking about this problem from the ground up and realized that static analysis solves key blind spots of LLM-only reviews. Over the past six months, we built a new ‘hybrid’ agent loop that uses static analysis and frontier AI agents together to outperform both static-only and LLM-only tools in finding and fixing code quality and security issues. Today, we’re opening it up publicly.

Here’s how the hybrid architecture works:

- Static pass: 5,000+ deterministic checkers (code quality, security, performance) establish a high-precision baseline. A sub-agent suppresses context-specific false positives.

- AI review: The agent reviews code with static findings as anchors. Has access to AST, data-flow graphs, control-flow, import graphs as tools, not just grep and usual shell commands.

- Remediation: Sub-agents generate fixes. Static harness validates all edits before emitting a clean git patch.

Static solves key LLM problems: non-determinism across runs, low recall on security issues (LLMs get distracted by style), and cost (static narrowing reduces prompt size and tool calls).

On the OpenSSF CVE Benchmark [1] (200+ real JS/TS vulnerabilities), we hit 81.2% accuracy and 80.0% F1; vs Cursor Bugbot (74.5% accuracy, 77.42% F1), Claude Code (71.5% accuracy, 62.99% F1), CodeRabbit (59.4% accuracy, 36.19% F1), and Semgrep CE (56.9% accuracy, 38.26% F1). On secrets detection, 92.8% F1; vs Gitleaks (75.6%), detect-secrets (64.1%), and TruffleHog (41.2%). We use our open-source classification model for this. [2]

Full methodology and how we evaluated each tool: https://autofix.bot/benchmarks

You can use Autofix Bot interactively on any repository using our TUI, as a plugin in Claude Code, or with our MCP on any compatible AI client (like OpenAI Codex).[3] We’re specifically building for AI coding agent-first workflows, so you can ask your agent to run Autofix Bot on every checkpoint autonomously.

Give us a shot today: https://autofix.bot. We’d love to hear any feedback!

---

[1] https://github.com/ossf-cve-benchmark/ossf-cve-benchmark

[2] https://huggingface.co/deepsource/Narada-3.2-3B-v1

[3] https://autofix.bot/manual/#terminal-ui

I'm building an open source Amazon.

In other words, an open source decentralized marketplace. But like Carl Sagan said, to make an apple pie from scratch, you must first invent the universe.

So first I had to make open source management systems for every vertical. I'm launching the first one today, Openfront e-commerce, an open source Shopify alternative. Next will be Openfront restaurant, Openfront grocery, and Openfront gym.

And all of these Openfronts will connect to our decentralized marketplace, "the/marketplace", seamlessly. Once we launch other Openfronts, you'll be able to do everything from booking hotels to ordering groceries right from one place with no middle men. The marketplace simply connects to the Openfront just like its built-in storefront does.

Together, we can use open source to disrupt marketplaces and make sure sellers, in every vertical, are never beholden to them.

Marketplace: https://marketplace.openship.org

Openfront platforms: https://openship.org/openfront-ecommerce

Source code: https://github.com/openshiporg/openfront

Demo - Openfront: https://youtu.be/jz0ZZmtBHgo

Demo - Marketplace: https://youtu.be/LM6hRjZIDcs

Part 1 - https://news.ycombinator.com/item?id=32690410

Hi HN!

I'm building a JavaScript debugger called Wirebrowser. It combines network inspection, request rewriting, heap snapshots, and live object search.

The main experimental feature is BDHS (Breakpoint-Driven Heap Search): it hooks into the JavaScript debugger and automatically captures a heap snapshot at every pause and performs a targeted search for the value or structure of interest. This reveals the moment a value appears in memory and the user-land function responsible for creating it.

Another interesting feature is the Live Object Search: it inspects runtime objects (not just snapshots), supports regex and object similarity, and lets you patch objects directly at runtime.

Whitepaper: https://fcavallarin.github.io/wirebrowser/BDHS-Origin-Trace

Feedback very welcome, especially on whether BDHS would help your debugging workflow.

Mobile keyboards today are almost entirely based on the 26-key, 3-row QWERTY layout. Here’s a new 2-row, 16-key alternative designed specifically for smartphones.

Built this over the last few days, based on a Rust codebase that parses the latest ALPR reports from OpenStreetMaps, calculates navigation statistics from every tagged residential building to nearby amenities, and tests each route for intersection with those ALPR cameras (Flock being the most widespread).

These have gotten more controversial in recent months, due to their indiscriminate large scale data collection, with 404 Media publishing many original pieces (https://www.404media.co/tag/flock/) about their adoption and (ab)use across the country. I wanted to use open source datasets to track the rapid expansion, especially per-county, as this data can be crucial for 'deflock' movements to petition counties and city governments to ban and remove them.

In some counties, the tracking becomes so widespread that most people can't go anywhere without being photographed. This includes possibly sensitive areas, like places of worship and medical facilities.

The argument for their legality rests upon the notion that these cameras are equivalent to 'mere observation', but the enormous scope and data sharing agreements in place to share and access millions of records without warrants blurs the lines of the fourth amendment.

Hey HN! Like most here regular meetings have always been a big part of my work.

Over the years I've learned the value of active note taking in these meetings. Meaning: not minutes, not transcriptions or AI summaries, but me using my brain to actively pull out the key points in short form bullet-like notes, as the meeting is going on, as I'm talking and listening (and probably typing with one hand). This could be agenda points to cover, any interesting sidebars raised, insights gotten to in a discussion, actions agreed to (and a way to track whether they got done next time!).

It's both useful just to track what's going on in all these different meetings week to week (at one point I was doing about a dozen 1-1s per week, and it just becomes impossible to hold it in RAM) but also really valuable over time when you can look back and see the full history of a particular meeting, what was discussed when, how themes and structure are changing, is the meetings effective, etc.

Anyway, I've tried a bunch of different tools for taking these notes over the years. All the obvious ones you've probably used too. And I've always just been not quite satisfied with the experience. They work, obviously (it's just text based notes at the end of the day) but nothing is first-class for this usecase.

So, I decided to build the tool I've always felt I want to use, specifically for regular 1-1s and other types of regular meetings. I've been using it myself and with friends for a while already now, and I think it's got to that point where I actually prefer to reach for it over other general purpose note taking tools now, and I want to share it more widely.

There's a free tier so you can use it right away, in fact without even signing up.

If you've also been wanting a better system to manage your notes for regular meetings, give it a go and let me know what you think!

I built AlgoDrill because I kept grinding LeetCode, thinking I knew the pattern, and then completely blanking when I had to implement it from scratch a few weeks later.

AlgoDrill turns NeetCode 150 and more into pattern-based drills: you rebuild the solution line by line with active recall, get first principles editorials that explain why each step exists, and everything is tagged by patterns like sliding window, two pointers, and DP so you can hammer the ones you keep forgetting. The goal is simple: turn familiar patterns into code you can write quickly and confidently in a real interview.

https://algodrill.io

Would love feedback on whether this drill-style approach feels like a real upgrade over just solving problems once, and what’s most confusing or missing when you first land on the site.

Powerlifting programming isn’t as complicated as spreadsheets make it look; once you strip away the noise, the structure fits comfortably on a phone. I think of it as two parts: plain sets/weight/reps/RPE/1RM, and the custom analytics you build on top. SigmaLifting handles the first part entirely on your phone with a mobile-first UI and a flexible data model that can express most spreadsheet-style programs. For the second part, you export the data and run it through your own tools (or an LLM) for whatever analysis you want.

Hi HN, I've always been interested in fractals, especially the Mandelbrot and Julia sets. A few years ago I created a 2d viewer of this inherently 4d space. But the other day I decided to ask Claude and GPT how to make this a full RT 3d explorer. A few hours later and this was vibe coded.

To use it you can use the mouse to rotate the fractal the the mouse wheel to zoom in and out. to map from 4d to 3d, one of the dims is mapped to an adjustable slider. the there is also a clipping plane slider to help visualize the internal structures of the fractal.

I have mixed feelings about vibe coding. It was amazing to go from an idea to live implementation within a few hours, but in my coding projects, I've always appreciated the journey and the learning, not just the final product. Vibe coding kind of skips to the end which is exciting and efficient, but just not as fulfilling as struggling through a project step-by-step.