Show stories

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.

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.

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.

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 GitPulse to solve a problem I had: finding beginner-friendly repos.

Features: • 200+ curated “good first issues” • AI-powered difficulty predictor • Smart repo matching • Contributor analytics • Repo health score

Live: https://git-pulsee.vercel.app

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?

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.

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’m launching UsageFlow, a simple tool for API owners who want automatic API usage metering and full control over their endpoints — all without any hassle.

With just a few lines of code, the UsageFlow SDK gives you:

Automatic discovery of API endpoints

User identification

Usage metering

Rate-limits and automatic blocking

Reporting usage events to your existing billing or metering system

Supports: Go (Gin), Python (FastAPI, Flask), Node.js (Express, Fastify, NestJS)

Perfect for AI APIs or SaaS platforms that want to scale fast — focus on building your product while UsageFlow handles usage tracking automatically.

No developer skills required to:

Update usage rules

Apply limits

Report usage

Everything works with a few clicks — your entire usage platform is in your hands, instantly.

I’m opening this for first testers. If you run an API and want to try UsageFlow, comment below or DM me — I will create your account and get you started in minutes.

Learn more at: https://usageflow.io

Hi HN! I built Docuglean, an open-source SDK for intelligent document processing that works with OpenAI, Mistral, Google Gemini, and Hugging Face models.

The idea came from repeatedly writing boilerplate code to extract structured data from invoices, receipts, and other documents. Instead of wrestling with different API formats, I wanted a unified interface that:

- Extracts structured data using Zod/Pydantic schemas - Classifies and splits multi-section documents (e.g., medical records) - Processes documents in batches with automatic error handling - Works locally without APIs (for PDFs, DOCX, XLSX, etc.)

Key features: - Available for both TypeScript and Python - Batch processing with concurrent requests - Document classification (splits 100+ page docs by category) - Local parsers (no API needed for basic extraction) - Apache 2.0 licensed

Currently supports OpenAI, Mistral, Gemini, and Hugging Face. Planning to add Together AI, Anthropic, and more.

Would love feedback on the API design and what features would be most useful

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

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.

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.

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!

I built a CLI to benchmark DNS resolvers after discovering DNS was adding 300ms to my API requests.

v0.3.0 just released with new features: compare: Test single domain across all resolvers top: Rank resolvers by latency/reliability/balanced monitor: Continuous tracking with threshold alerts

1,400+ downloads in first week.

Quick start: pip install dns-benchmark-tool dns-benchmark compare --domain google.com

CLI stays free forever. Hosted version (multi-region, historical tracking, alerts) coming Q1 2026.

GitHub: https://github.com/frankovo/dns-benchmark-tool Feedback: https://forms.gle/BJBiyBFvRJHskyR57

Built with Python + dnspython. Open to questions and feedback!

Hi HN — we've built a testing framework for Supabase that spins up fast, isolated Postgres databases for each test case. It’s designed to make RLS policies easy to validate with real database state, without global test fixtures or mock auth.

Features: - Instant isolated Postgres DBs per test - Automatic rollback after each test - RLS-native testing with `.setContext()` for auth simulation - Flexible seeding (SQL, CSV, JSON, JS) - Works with Jest, Mocha, and any async test runner - CI-friendly (runs cleanly in GitHub Actions)

We also published example projects and a free set of tutorials: https://launchql.com/learn/supabase

Package: https://www.npmjs.com/package/supabase-test

Source + full test suite: https://github.com/launchql/supabase-test-suite

Happy to answer questions and get feedback, cheers :)

I built YAAT for EU companies that can't of send data to US servers or being locked into pre-built dashboards that can't answer custom questions.

What makes it different:

Direct SQL access to your data. Not just pre-built reports – write actual queries against your raw events. Want to know which UTM campaigns convert best for mobile users in Germany? Write the query, get the answer, save it as a dashboard panel.

Full analytics stack:

Web analytics: pageviews, sessions, traffic sources, UTM tracking, device/browser/geo data Error tracking: JavaScript exceptions, unhandled promises, stack traces, filtering by browser/version Performance monitoring: Core Web Vitals (LCP, FID, CLS, INP), page load times, TTFB

Custom dashboards: Drag-drop panels anywhere. Time series, bar charts, pie charts, maps, tables. Monaco editor with SQL autocomplete. Export data as Parquet files – full ownership.

Privacy-first: EU-hosted infrastructure (no data transfers), GDPR-compliant, no cookies needed, lightweight script (<2KB).

Domain verification via DNS ensures only your sites can send data.

Current state: Beta with 7 verified domains tracking production traffic. Looking for 10 EU companies to test for 3 months free.

Want feedback on SQL interface and what analytics patterns matter most for your business.

Try it: https://yaat.io/beta

Built in Valencia, Spain. All data stays in EU.

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

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.

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.

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-...

Hi HN,

A couple of months ago I posted an early version of this Chrome extension. Since then I’ve refined it, fixed a bunch of stability issues, and it was recently featured on the Chrome Web Store’s “Featured” section, which was a nice surprise.

What the extension does: – Detects the active tweet or thread directly in the browser – Collects relevant context (parent tweet, author info, thread shape) – Formats a prompt and sends it to the OpenAI API – Inserts the generated reply straight into Twitter’s native reply box

All of this happens inside the X.com DOM, without storing any user data.

Technical bits: – Uses MutationObserver to track X.com’s constantly changing DOM – Handles dynamically inserted tweet nodes, shadow DOM, and thread expansions – Debounces context extraction to avoid unnecessary re-runs – Simulates native input events to inject the reply so it feels built-in – Avoids backend state; everything is read client-side except the final API call

Challenges: – X.com changes UI structure often, so selectors break unpredictably – Preventing duplicate injections when the DOM re-renders – Keeping prompt size small enough for fast generation – Reducing overhead so the extension doesn’t slow down the page

Recent improvements: – More stable tweet/thread detection – Better context selection logic – Cleaner UI in the reply popup – Small performance fixes and race-condition fixes

Chrome Store page: https://chromewebstore.google.com/detail/xinsightai-ai-reply...

Would appreciate feedback from people who’ve built browser extensions or dealt with X.com’s DOM patterns. Happy to discuss any details.

Hi HN! We're excited to release our VS Code/Cursor extension for marimo [1], an open-source, reactive Python notebook.

This extension provides a native experience for working with marimo notebooks, a long-requested feature that we’ve worked hard to get right.

An LSP-first architecture

The core of our extension is a marimo notebook language server (marimo-lsp [2]). As far as we know, it’s the first notebook runtime to take this approach. The Language Server Protocol (LSP) [3] offers a small but important set of notebook-related capabilities that we use for document and kernel syncing; everything else is handled through custom actions and messages.

By building on LSP, we aim to create a path to expose marimo capabilities in additional environments (beyond VS Code/Cursor). The notebook features in LSP are still limited, but as the protocol evolves, we’ll be able to shift more functionality out of the extension and into the language server, making it available to a wider range of editors and tools. For example, this could enable:

- structural edits to notebook documents (e.g., adding or removing cells) [4]

- editor hover information that reflects the live runtime values of variables

Deep uv integration with PEP 723

Because marimo notebooks are plain Python files, we adopt PEP 723-style inline metadata [5] to describe a notebook’s environment. Tools such as uv already support this format: they read the metadata block, build or update the corresponding environment, and run the script inside it.

The marimo CLI already integrates with uv in "sandbox" mode [6] to manage an isolated environment defined by PEP 723 metadata for a single notebook. In the extension, our uv-based “sandbox controller” manages multiple notebooks: each notebook gets its own isolated, cached environment. The controller keeps the environment aligned with the dependencies declared in the file and can update that metadata automatically when imports are missing.

uv normally syncs such environments whenever you run a script, ensuring it matches the dependencies declared in its metadata; we apply this concept at the cell level so the environment stays in sync whenever cells run. The same cached uv environment is reused if you run the notebook as a script via uv (e.g., uv run notebook.py).

—-------

This work has been a complete rewrite, and we're grateful to the community for early feedback. While VS Code and the LSP support a subset of notebook features, the ecosystem has been shaped heavily by Jupyter, and we’ve had to work around some assumptions baked into existing APIs. We’ve been coordinating with the VS Code team and hope our work can help broaden the conversation—pushing the LSP notebook model forward and making room for runtimes that aren’t Jupyter-based.

We'd love to hear your thoughts!

[1] https://marimo.io

[2] https://github.com/marimo-team/marimo-lsp

[3] https://microsoft.github.io/language-server-protocol/

[4] https://github.com/microsoft/vscode-languageserver-node/issu...

[5] https://peps.python.org/pep-0723/

[6] https://docs.marimo.io/guides/package_reproducibility/

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.

CTON is an open-source, command-line tool that converts various data formats, including JSON, YAML, XML, and CSV, into each other. It provides a simple and efficient way to transform data between different structures, making it useful for data processing and integration tasks.

The article explores the process of reversing the communication protocol used by the FS7 camera system, providing insights into the technical implementation and potential applications for developers and enthusiasts in the field of camera control and automation.

I built Wasda, a tiny experiment to turn transformer attention into a playable musical instrument. Each token in the sequence becomes a piano note, and you can see the attention arcs between tokens while you listen. Temperature controls the “improvisation” of the model, and you can solo individual attention heads — for example, I’ve found temp ~1.7 with one head selected gives surprisingly relaxing patterns.