Show stories

Hi HN, creator of Wealthfolio here.

A year ago, I posted the first version. Since then, the app has matured significantly with two major updates:

1. Multi-platform Support: Now available on Mobile (iOS), Desktop (macOS, Windows, Linux), and as a Self-hosted Docker image. (Android coming soon).

2. Addons System: We added explicit support for extensions so you can hack around, vibe code your own integrations, and customize the app to fit your needs.

The core philosophy remains the same: Always private, transparent, and open source.

Like a lot of people I got the $250 Claude Code credit and didn't use it up.

I decided to try to use it up over the weekend using (mostly) my phone and vibe coded a Prolog interpreter.

Now I'm seeing how far I can push it.

Hi HN

I have been working on Skedular a platform that helps organizations councils co working spaces and local businesses manage bookings shared spaces and multi location operations in a simple modern way

What Skedular does

  - Manage rooms desks studios sports facilities meeting spaces and any kind of bookable asset
  - Handle multi location multi team scenarios
  - Provide public booking pages for venues
  - Offer a clean dashboard for operators to manage availability payments customers and schedules
  - API first design for easy integration with existing systems
  - Built with modern tooling including Nextjs NET backend PostGIS and Kafka events

Most booking platforms are either too simple or too enterprise heavy Skedular is meant to sit in the middle powerful enough for councils or large organisations but simple enough for a local venue owner to use without training.

I am currently onboarding early users and would love feedback from this community especially around UX data modelling and scaling patterns.

Links

  - Public website https://getskedular.com
  - App website https://skedular.app

I would appreciate thoughts on the overall concept any edge cases I might be missing suggestions for UI and UX improvements and pain points you have experienced in managing bookings or shared resources

Thanks for taking a look Morteza

Inspired by All Text in NYC (https://alltext.nyc) by Yufeng Zhang I thought I would replicate something similar for London.

A searchable tool that lets you explore text captured across Google Street View imagery in London; shop signs, posters, graffiti, van numbers etc

As part of a little research and also some fun I decided to try my hand at seeing how small of an ESP32 board I can make with functioning WiFi.

The article discusses the potential impact of technological advancements on the future job market, highlighting the possible rise of automation and the need for workers to adapt their skills to maintain employment in the coming decades.

Astral OS, a newly launched operating system, has announced support for running Minecraft on its platform. This integration aims to provide a seamless and optimized Minecraft experience for users of the Astral OS ecosystem.

I made a Terminal UI for OpenSnitch[1], an interactive application firewall for Linux inspired by Little Snitch. I’ve always wanted to create a TUI and found the perfect excuse to make this for usage on one of my headless servers.

I wrote this in Rust to force myself to learn more, viz. async features. Super open to feedback and contributions!

[1] https://github.com/evilsocket/opensnitch

An awesome list about Java platform Micro edition(J2ME). Documentation, academic papers, tutorials, communities, IDEs, SDKs, emulators, apps, video games. J2ME is a Java specification designed for old keypad phones and PDAs. MIDP, which is built upon CLDC, is used to create Midlets, which have `.jad` or `.jar` extension, and run on platforms like old keypad phones, Symbian and PDAs. MIDP is supported till Java ME SDK 3.4.

I built OCR Arena as a free playground for the community to compare leading foundation VLMs and open-source OCR models side-by-side.

Upload any doc, measure accuracy, and (optionally) vote for the models on a public leaderboard.

It currently has Gemini 3, dots.ocr, DeepSeek, GPT5, olmOCR 2, Qwen, and a few others. If there's any others you'd like included, let me know!

After down detector went down with the rest of the internet during the Cloudflare outage today I decided to build a robust, independent tool which checks if down detector is down. Enjoy!!

I am a dad and have a hard time keeping track of who's turn it is, so I built this simple app to help, and you can try it out and use it for free!

You can create a list, add turns (in order), and advance the turns in sequential or random order. That is pretty much it.

I guess a to-do list or something could do something similar, but this is designed with 'taking turns' in mind.

It's a PWA, so you can "Add to Homescreen" rather than download an app from the app store. Or use it in your browser.

I've been using it every day for a bit now, thought I'd share.

The article discusses the author's decision to build a custom synthesizer for their young daughter, focusing on the educational and bonding benefits of introducing her to music and electronics at an early age.

City2Graph is a tool that transforms city maps into graph-based representations, allowing for efficient analysis and visualization of urban infrastructure and transportation networks.

The article discusses the MCP-Shark project, an open-source platform that enables researchers to develop, test, and deploy machine learning models for underwater shark detection and tracking. It highlights the project's focus on leveraging computer vision and deep learning techniques to support marine conservation efforts.

Claude Code is great, but it’s focused on coding. The missing piece is a native way to build and run custom background agents for non-code tasks. We built RowboatX as a CLI tool modeled after Claude Code that lets you do that. It uses the file system and unix tools to create and monitor background agents for everyday tasks, connect them to any MCP server for tools, and reason over their outputs.

Because RowboatX runs locally with shell access, the agents can install tools, execute code, and automate anything you could do in a terminal with your explicit permission. It works with any compatible LLM, including open-source ones.

Our repo is https://github.com/rowboatlabs/rowboat, and there’s a demo video here: https://youtu.be/cyPBinQzicY

For example, you can connect RowboatX to the ElevenLabs MCP server and create a background workflow that produces a NotebookLM-style podcast every day from recent AI-agent papers on arXiv. Or you can connect it to Google Calendar and Exa Search to research meeting attendees and generate briefs before each event.

You can try these with: `npx @rowboatlabs/rowboatx`

We combined three simple ideas:

1. File system as state: Each agent’s instruction, memory, logs, and data are just files on disk, grepable, diffable, and local. For instance, you can just run: grep -rl '"agent":"<agent-name>"' ~/.rowboat/runs to list every run for a particular workflow.

2. The supervisor agent: A Claude Code style agent that can create and run background agents. It predominantly uses Unix commands to monitor, update, and schedule agents. LLMs handle Unix tools better than backend APIs [1][2], so we leaned into that. It can also probe any MCP server and attach the tools to the agents.

3. Human-in-the-loop: Each background agent can emit a human_request message when needed (e.g. drafting a tricky email or installing a tool) that pauses execution and waits for input before continuing. The supervisor coordinates this.

I started my career over a decade ago building spam detection models at Twitter, spending a lot of my time in the terminal with Unix commands for data analysis [0] and Vowpal Wabbit for modeling. When Claude Code came along, it felt familiar and amazing to work with. But trying to use it beyond code always felt a bit forced. We built RowboatX to bring that same workflow to everyday tasks. It is Apache-2.0 licensed and easily extendable.

While there are many agent builders, running on the user's terminal enables unique use cases like computer and browser automation that cloud-based tools can't match. This power requires careful safety design. We implemented command-level allow/deny lists, with containerization coming next. We’ve tried to design for safety from day one, but we’d love to hear the community’s perspective on what additional safeguards or approaches you’d consider important here.

We’re excited to share RowboatX with everyone here. We’d love to hear your thoughts and welcome contributions!

—

[0] https://web.stanford.edu/class/cs124/kwc-unix-for-poets.pdf [1] https://arxiv.org/pdf/2405.06807 [2] https://arxiv.org/pdf/2501.10132

Hi HN! We’re Ethan and Danny, the authors of Tangent (https://github.com/telophasehq/tangent), a Rust-based log pipeline where all normalization, enrichment, and detection logic runs as WASM plugins.

We kept seeing the same problems in the OCSF (https://ocsf.io) community: 1) Schemas change constantly. Large companies have whole teams dedicated to keeping vendor→OCSF mappings up to date. 2) There’s no shared library of mappings, so everyone recreates the same work. 3) Writing mappers is tedious, repetitive work. 4) Most pipelines use proprietary DSLs that are hard to share and hard for tools/LLMs to generate.

Tangent takes a different approach: no DSLs – mappings and enrichments are just normal code compiled to WASM, shareable plugins – we maintain a community library (https://github.com/telophasehq/tangent-plugins), interoperability – we can run other engines’ DSLs (e.g., Bloblang) inside WASM for easy migration, full flexibility – plugins can validate schemas, call external APIs (https://github.com/telophasehq/tangent/blob/main/examples/en...), or perform complex transforms (https://github.com/telophasehq/tangent-plugins/blob/main/zee...).

Here's an example Python transformation plugin to drop all fields from a log except `message`:

  import json
  
  from typing import List
  
  from wit_world.imports import log
  
  # `log.Logview` is Tangent's zero-copy JSON accessor type.
  
  def process_logs(self, logs: List[log.Logview]) -> bytes:
  
      out = bytearray()
  
      for lv in logs:
  
          msg = lv.get("msg")
  
          value = msg.value if msg is not None else ""
  
          out.extend(json.dumps({"message": value}).encode() + b"\n")
  
      return bytes(out)

Because plugins are just Go/Python/Rust, LLMs can create new mappers with ease. For example, I asked:

  Generate a mapper from AWS Security Hub Finding to OCSF

Performance-wise, a 16-core Amazon Linux box processes ~480 MB/s end-to-end (TCP → Rust-WASM transform → sink) on ~100-byte JSON logs. The CLI includes tooling to scaffold, test, and benchmark plugins locally. Here's a deep dive into how we are able to get this performance: https://docs.telophasehq.com/runtime.

We’d love to get your feedback! What do you think?

StartupGambit.com provides insights and advice for entrepreneurs, covering topics such as fundraising, business strategy, and growth hacking. The site features articles written by experienced founders and industry experts to help startups navigate the challenges of building a successful business.

Use hns, a speech-to-text CLI tool to transcribe your voice from your microphone directly to clipboard. Integrate hns with Claude Code, Ollama, LLM, and more CLI tools for powerful workflows.

hns transcribes your voice 100% locally using faster-whisper. The whisper model is downloaded automatically on first run and after that, hns can be used completely offline. After transcription, the text is displayed in the terminal (written to stdout) as well as automatically copied to your clipboard, ready to be pasted anywhere with Ctrl+V or Cmd+V.

GitHub: https://github.com/primaprashant/hns/

This is a draft of a second edition of this book from SIAM https://epubs.siam.org/doi/book/10.1137/1.9780898717747?mobi...

There are three things to show:

1. A pdf of the draft: https://www.fraserphysics.com/book.pdf

2. The hmm project which provides code for state-space models: https://gitlab.com/fraserphysics/hmm with documentation at https://fraserphysics.gitlab.io/hmm/

3. The hmmds project which provides code for using state-space models to address some examples: https://gitlab.com/fraserphysics/hmmds with doumentation at https://fraserphysics.gitlab.io/hmmds/ The default target for hmmds is to build the book. On my home system it takes about 10 hours to build the book.

I would be grateful for comments or suggestions on any aspect of any of the three things.

I am particularly interested in help with the following:

1. I use NixOS for developing. I've documented progress on making the code useful in other enviroments at https://fraserphysics.gitlab.io/hmmds/getting_started.html Please let me know if you are able to use the code elsewhere.

2. In the draft of the book, I have an analysis of the convergence properties of the EM algorithm spread between Section 2.5 "The EM algorithm" on page 43 and Appendix B "EM Convergence Rate" on page 137. The analysis is different from anything I've seen published. I would like feedback with corrections and or citations.

Hi everyone, I'm the author of ESPectre.

This is an open-source (GPLv3) project that uses Wi-Fi signal analysis to detect motion using CSI data, and it has already garnered almost 2,000 stars in two weeks.

Key technical details:

- The system does NOT use Machine Learning, it relies purely on Math. — Runs in real-time on a super affordable chip like the ESP32. - It integrates seamlessly with Home Assistant via MQTT.

I built a Rust-based CLI/terminal UI for inspecting Parquet files—data, metadata, and row-group-level structure—right from the terminal. If someone sent me a Parquet file, I used to open DuckDB or Polars just to see what was inside. Now I can do it with one command.

Repo: https://github.com/kaushiksrini/parqeye

Features include:

  - Several preset periodic orbits: the classic Figure-8, plus newly discovered 3D solutions from Li and Liao's recent database of 10,000+ orbits (https://arxiv.org/html/2508.08568v1)
  - Full 3D camera controls (rotate/pan/zoom) with body-following mode
  - Force and velocity vector visualization
  - Timeline scrubbing to explore the full orbital period

Built with Three.js. Open to suggestions for additional presets or features!

Lightweight Chrome DevTools extension for capturing, replaying, and editing HTTP requests. No proxy or CA setup needed. Features regex search, Base64/URL/JWT converters (will add more), screenshots, request history, and pinned requests, the extension is ideal for bug bounty hunters, AppSec engineers, and DevSecOps engineers :D

Sequence Toys is an educational technology company that develops interactive, programmable toys to teach children the fundamentals of coding and computational thinking through engaging and hands-on experiences.

Hi HN!

I built CodeSprint because I realized getting good at typing code requires practicing syntax fluency, not just logic. I found myself screwing up on mock interviews not because I didn't know the algorithm, but because I fumbled the syntax. I needed a way to drill "Depth First Search in Python" or "Ring Buffer in C++" until my fingers actually knew the shape of the code.

The Engineering:

Renderer: Uses a heavily customized Monaco Editor instance. I'm using deltaDecorations to paint diffs directly onto the editor model without breaking syntax highlighting, and getScrolledVisiblePosition for a custom, low-latency caret.

Data Pipeline: I didn't want to hardcode snippets. I wrote a custom Bun script (scripts/sync-leetcode.ts) that reverse-engineers the LeetCode GraphQL API to pull real problem snippets, sanitizes them, and normalizes indentation.

Latency: To handle high WPM without UI lag, the typing engine isolates keystroke processing from the main React render cycle where possible.

Repo: https://github.com/cwklurks/codesprint Live Demo: https://codesprints.vercel.app/

I'm a 15-year-old student from Vancouver. Would love feedback on the typing engine feel vs. native VS Code!

Continuous Claude is a CLI wrapper I made that runs Claude Code in an iterative loop with persistent context, automatically driving a PR-based workflow. Each iteration creates a branch, applies a focused code change, generates a commit, opens a PR via GitHub's CLI, waits for required checks and reviews, merges if green, and records state into a shared notes file.

This avoids the typical stateless one-shot pattern of current coding agents and enables multi-step changes without losing intermediate reasoning, test failures, or partial progress.

The tool is useful for tasks that require many small, serial modifications: increasing test coverage, large refactors, dependency upgrades guided by release notes, or framework migrations.

Blog post about this: https://anandchowdhary.com/blog/2025/running-claude-code-in-...

In the cold season we tend to keep the windows closed. The air gets "stale": humidity often rises above 60 %, which can harm our wellbeing and promote mould. At the same time the CO₂ level in the air increases, which impacts our ability to concentrate.

So I built a room air monitor that stays unobtrusive as long as everything is in the green zone, but becomes deliberately noticeable once thresholds are exceeded. For my personal love of statistics I also visualise the measurements in a clear dashboard.

After the major outages from AWS and Cloudflare, I began wondering how to make my own services more resilient.

Using nameservers from different providers is doable but a bit tricky to manage. OctoDNS helps automate keeping the zones synced so AWS, Cloudflare, etc. are all serving the same information.

In an age of centralized infrastructure, we can exploit the capabilities from the origins of the decentralized internet.