Show stories

Throughout my career in embedded systems — automotive (ASPICE), medical, avionics, CMMI environments — I've seen teams struggle with the same problem: requirements traceability. The options were always frustrating:

Expensive, heavy tools like DOORS that don't fit modern dev workflows JIRA-based workarounds that slow everything down and integrate poorly with code

So I built SARA (Solution Architecture Requirements for Alignment): a CLI that treats architecture documents and requirements as a knowledge graph. The core idea: your requirements are too important to be locked in proprietary systems. SARA uses plain Markdown + YAML frontmatter, which means:

Full Git workflows (branching, code review, versioning) No vendor lock-in — switch tools anytime, your data stays readable AI/LLM-ready format for automated analysis

Features:

Multi-repo support Traceability queries (upstream/downstream) Validation (broken refs, cycles, duplicates, orphans) Coverage reports and traceability matrices

Coming soon: ADR support and MCP server for AI assistant integration. Written in Rust. Free and open-source. https://github.com/cledouarec/sara Would love feedback from anyone who's dealt with requirements management pain.

This article discusses the development of a tool called AutoShorts, which automatically generates short video clips from long-form video content. The tool uses machine learning techniques to identify key moments and summarize the content, enabling efficient content repurposing and distribution.

Hi HN,

I built *Sightline*, a Shodan-style search engine for *physical-world infrastructure*.

Shodan makes it easy to explore exposed internet services. Sightline applies the same idea to the real world, using OpenStreetMap as the data source.

You can search things like:

* “telecom towers in karnataka” * “power plants near mumbai” * “data centers in paris france”

or use structured queries:

* `type:telecom operator:airtel region:karnataka` * `type:data_center operator:google`

Sightline:

* uses Overpass API for querying OSM features * uses Nominatim for resolving countries, regions, and cities * avoids hardcoded geography * uses deterministic, rule-based parsing (no AI inference)

Repo: https://github.com/ni5arga/sightline Try it out: https://sightline-maps.vercel.app

Seven modules teaching C the way safety-critical systems are actually built: MATH → STRUCT → CODE → TEST.

Each module answers one question: Does it exist? (Pulse), Is it normal? (Baseline), Is it regular? (Timing), Is it trending? (Drift), Which sensor to trust? (Consensus), How to handle overflow? (Pressure), What do we do about it? (Mode).

Every module is closed (no dependencies), total (handles all inputs), deterministic, and O(1). 83 tests passing.

Built this after 30 years in UNIX systems. Wanted something that teaches the rigour behind certified systems without requiring a decade of on-the-job learning first.

MIT licensed. Feedback welcome.

I've long wanted to harness QEMU/KVM for my desktop virtual machines, but I'm befuddled by virt-manager's lack of support for working NVIDIA 3D acceleration, dogmatic embrace of ugly XML, and the puzzling UI decision of having to click what seems like 15 buttons to attach an ISO to a VM image. When I further learned that NVIDIA's broken 3D acceleration is the fault of libvirt as opposed to QEMU's virtio driver, I had an idea...

Behold, vm-curator! A fast and friendly VM management TUI written in Rust. You can create, configure, organize, and manage VMs directly with QEMU. No libvert. No XML. No wonky UI's. Just the right level of friendliness, customization, and speed to be really really useful.

The best part? 3D para-virtualization works with NVIDIA cards (via virtio-vga-gl!) No jumping through hoops to get GPU passthrough working!

(Disclaimer: This works great with other guest Linux VMs, but is not suitable for Windows gaming. If you want to game on Windows within a VM, passthrough is a must. vm-curator will have fast and friendly support soon.)

Looking for contributors (especially to help with the ascii art,) and donations are welcome. (Claude was a big help, but this was not a vibe-coded affair. We pair-programmed approx. 10,000 lines of code here. It was a great way to learn Rust, actually!)

Basically was getting annoyed jumping between 5 different sites during this winter storm season, so I built "StormWatch". It's a no-fuss, mobile-friendly webpage (dashboard) that shows all the stuff I was looking for, but in one simple UI.

Features:

- Real-time NWS alerts with safety tips - Snow/ice/precip accumulation forecasts (+wind) - Dynamic preparation checklists based on your alerts - Supply calculator for your household size - Regional weather news

It's free, no login required, works on any device. Just enter your ZIP.

https://jeisey.github.io/stormwatch/

Uses NWS and GDELT APIs and open source. Feel free to fork and modify however you'd like.

For builders: - Used an API-testing agent to verify all endpoints, response patterns, types, and rate limits - Used a scope & validation agent to keep the slices simple, focused, and tested - VS-code Copilot (Sonnet 4 for dev agents + Opus 4.5 for scope and validation)

Hi HN, founders of VibeFlow (YC S25) here.

We mostly work on backend and workflow tooling, but we needed a way to turn Figma designs into frontend code as a kickstart for prototyping. It takes a Figma frame and converts it into React + Tailwind components (plus assets).

If you want to try it: You can run it locally or use it via the VibeFlow UI to poke at it without setup (https://app.vibeflow.ai/)

Hey HN! I built Lumina – an open-source observability platform for AI/LLM applications. Self-host it in 5 minutes with Docker Compose, all features included.

The Problem:

I've been building LLM apps for the past year, and I kept running into the same issues: - LLM responses would randomly change after prompt tweaks, breaking things - Costs would spike unexpectedly (turns out a bug was hitting GPT-4 instead of 3.5) - No easy way to compare "before vs after" when testing prompt changes - Existing tools were either too expensive or missing features in free tiers

What I Built:

Lumina is OpenTelemetry-native, meaning: - Works with your existing OTEL stack (Datadog, Grafana, etc.) - No vendor lock-in – standard trace format - Integrates in 3 lines of code

Key features: - Cost & quality monitoring – Automatic alerts when costs spike or responses degrade - Replay testing – Capture production traces, replay them after changes, see diffs - Semantic comparison – Not just string matching – uses Claude to judge if responses are "better" or "worse" - Self-hosted tier – 50k traces/day, 7-day retention, ALL features included (alerts, replay, semantic scoring)

How it works:

Start Lumina

git clone https://github.com/use-lumina/Lumina cd Lumina/infra/docker docker-compose up -d

// Add to your app (no API key needed for self-hosted!)

import { Lumina } from '@uselumina/sdk';

const lumina = new Lumina({ endpoint: 'http://localhost:8080/v1/traces', });

// Wrap your LLM call const response = await lumina.traceLLM( async () => await openai.chat.completions.create({...}), { provider: 'openai', model: 'gpt-4', prompt: '...' } );

That's it. Every LLM call is now tracked with cost, latency, tokens, and quality scores.

What makes it different:

1. Free self-hosted with limits that work – 50k traces/day and 7-day retention (resets daily at midnight UTC). All features included: alerts, replay testing, semantic scoring. Perfect for most development and small production workloads. Need more? Upgrade to managed cloud.

2. OpenTelemetry-native – Not another proprietary format. Use standard OTEL exporters, works with existing infra. Can send traces to both Lumina AND Datadog simultaneously.

3. Replay testing – The killer feature. Capture 100 production traces, change your prompt, replay them all, get a semantic diff report. Like snapshot testing for LLMs.

4. Fast – Built with Bun, Postgres, Redis, NATS. Sub-500ms from trace to alert. Handles 10k+ traces/min on a single machine.

What I'm looking for:

- Feedback on the approach (is OTEL the right foundation?) - Bug reports (tested on Mac/Linux/WSL2, but I'm sure there are issues) - Ideas for what features matter most (alerts? replay? cost tracking?) - Help with the semantic scorer (currently uses Claude, want to make it pluggable)

Why open source:

I want this to be the standard for LLM observability. That only works if it's: - Free to use and modify (Apache 2.0) - Easy to self-host (Docker Compose, no cloud dependencies) - Open to contributions (good first issues tagged)

The business model is managed hosting for teams who don't want to run infrastructure. But the core product is and always will be free.

Try it: - GitHub: https://github.com/use-lumina/Lumina - Demo video: [YouTube link] - Docs: https://docs.uselumina.io - Quick start: 5 minutes from `git clone` to dashboard

I'd love to hear what you think! Especially interested in: - What observability problems you're hitting with LLMs - Missing features that would make this useful for you - Any similar tools you're using (and what they do better)

Thanks for reading!

Hi HN! I built Ghibli Search, a semantic search engine for Studio Ghibli movie scenes (e.g. Spirited Away, My Neighbor Totoro, Howl's Moving Castle, etc.).

Describe a dreamscape like "flying through clouds at sunset" or upload an image, and it finds visually similar scenes from the films.

Live demo: https://ghibli-search.anini.workers.dev/

Full Cloudflare stack: Workers, AI Search, R2, Workers AI

Open source: https://github.com/aninibread/ghibli-search

Would love feedback on the search quality and any ideas for improvements!

I usually build web games in C++, but using Emscripten always felt like overkill for what I was doing. I don't need full POSIX emulation or a massive standard library just to render some stuff to a canvas and handle basic UI.

The main thing I wanted to solve was the JS/WASM interop bottleneck. Instead of using the standard glue code for every call, I moved everything to a Shared Memory architecture using Command and Event buffers.

The way it works is that I batch all the instructions in WASM and then just send a single "flush" signal to JS. The JS side then reads everything directly out of Shared Memory in one go. It’s way more efficient, I ran a benchmark rendering 10k rectangles on a canvas and the difference was huge: Emscripten hit around 40 FPS, while my setup hit 100 FPS.

But writing DOM logic in C++ is painful, so I built Coi. It’s a component-based language that statically analyzes changes at compile-time to enable O(1) reactivity. Unlike traditional frameworks, there is no Virtual DOM overhead; the compiler maps state changes directly to specific handles in the command buffer.

I recently benchmarked this against React and Vue on a 1,000-row table: Coi came out on top for row creation, row updating and element swapping because it avoids the "diffing" step entirely and minimizes bridge crossings. Its bundle size was also the smallest of the three.

One of the coolest things about the architecture is how the standard library works. If I want to support a new browser API (like Web Audio or a new Canvas feature), I just add the definition to my WebCC schema file. When I recompile the Coi compiler, the language automatically gains a new standard library function to access that API. There is zero manual wrapping involved.

I'm really proud of how it's coming along. It combines the performance of a custom WASM stack with a syntax that actually feels good to write (for me atleast :P). Plus, since the intermediate step is C++, I’m looking into making it work on the server side too, which would allow for sharing components across the whole stack.

Example (Coi Code):

component Counter(string label, mut int& value) {

    def add(int i) : void {
        value += i;
    }

    style {
        .counter {
            display: flex;
            gap: 12px;
            align-items: center;
        }
        button {
            padding: 8px 16px;
            cursor: pointer;
        }
    }

    view {
        <div class="counter">
            <span>{label}: {value}</span>
            <button onclick={add(1)}>+</button>
            <button onclick={add(-1)}>-</button>
        </div>
    }

component App { mut int score = 0;

    style {
        .app {
            padding: 24px;
            font-family: system-ui;
        }
        h1 {
            color: #1a73e8;
        }
        .win {
            color: #34a853;
            font-weight: bold;
        }
    }

    view {
        <div class="app">
            <h1>Score: {score}</h1>
            <Counter label="Player" &value={score} />
            <if score >= 10>
                <p class="win">You win!</p>
            </if>
        </div>
    }

app { root = App; title = "My Counter App"; description = "A simple counter built with Coi"; lang = "en"; }

Live Demo: https://io-eric.github.io/coi

Coi (The Language): https://github.com/io-eric/coi

WebCC: https://github.com/io-eric/webcc

I'd love to hear what you think. It's still far from finished, but as a side project I'm really excited about :)

I built Polymcp, a framework that allows you to transform any Python function into an MCP (Model Context Protocol) tool ready to be used by AI agents. No rewriting, no complex integrations.

Examples

Simple function:

from polymcp.polymcp_toolkit import expose_tools_http

def add(a: int, b: int) -> int: """Add two numbers""" return a + b

app = expose_tools_http([add], title="Math Tools")

Run with:

uvicorn server_mcp:app --reload

Now add is exposed via MCP and can be called directly by AI agents.

API function:

import requests from polymcp.polymcp_toolkit import expose_tools_http

def get_weather(city: str): """Return current weather data for a city""" response = requests.get(f"https://api.weatherapi.com/v1/current.json?q={city}") return response.json()

app = expose_tools_http([get_weather], title="Weather Tools")

AI agents can call get_weather("London") to get real-time weather data instantly.

Business workflow function:

import pandas as pd from polymcp.polymcp_toolkit import expose_tools_http

def calculate_commissions(sales_data: list[dict]): """Calculate sales commissions from sales data""" df = pd.DataFrame(sales_data) df["commission"] = df["sales_amount"] * 0.05 return df.to_dict(orient="records")

app = expose_tools_http([calculate_commissions], title="Business Tools")

AI agents can now generate commission reports automatically.

Why it matters for companies • Reuse existing code immediately: legacy scripts, internal libraries, APIs. • Automate complex workflows: AI can orchestrate multiple tools reliably. • Plug-and-play: multiple Python functions exposed on the same MCP server. • Reduce development time: no custom wrappers or middleware needed. • Built-in reliability: input/output validation and error handling included.

Polymcp makes Python functions immediately usable by AI agents, standardizing integration across enterprise software.

Repo: https://github.com/poly-mcp/Polymcp

Hi HN, I’m the creator of PodCost (https://podcost.io/).

I built this because as AI workloads move into production, GPU spend is becoming the largest line item on the cloud bill. Standard K8s cost tools often treat a node as a "black box," but when an A100 sits idle because of a misconfigured training job or a stuck inference server, you’re burning hundreds of dollars a day.

The Live Demo: I know how annoying it is to sign up just to see a dashboard. I’ve set up a demo cluster so you can see the ML-specific cost analysis and recommendations immediately:

URL: https://podcost.io/login

User: hackernews@podcost.io

Pass: hackernews@podcost.io

What’s inside:

ML Workload Analysis: It tracks costs per training job and inference request.

GPU Idle Detection: Automatically finds GPUs that are allocated but have low utilization.

Actionable Recommendations: It suggests specific rightsizing for pods and nodes based on actual historical usage.

Quick Setup: If you want to test it on your own cluster, it’s a single Helm command.

I’m particularly looking for feedback on our GPU recommendation engine. Is this a problem that you might pay for? also are those metrics shown in the demo cluster good enough? I am not building another observability tool. I am building AI cost saving tool that focuses on AI and GPU waste. your feedback will be really important for me.

I’ll be here to answer any technical questions!

Client-side app that pulls NWS data to attempt to show progression when you're in the middle of a major snowfall event.

Hey HN! I wanted to share something I built over the last few weeks: isometric.nyc is a massive isometric pixel art map of NYC, built with nano banana and coding agents.

I didn't write a single line of code.

Of course no-code doesn't mean no-engineering. This project took a lot more manual labor than I'd hoped!

I wrote a deep dive on the workflow and some thoughts about the future of AI coding and creativity:

http://cannoneyed.com/projects/isometric-nyc

EchoFluid is a privacy-first video and audio transcription tool I built to solve a problem I personally ran into: most transcription services require uploading the entire video file, which is slow, bandwidth-heavy, and sometimes not acceptable for sensitive content.

What’s different:

- Videos are processed locally in the browser to extract audio before upload

- Only the audio is sent for transcription, not the full video

This results in:

- Faster uploads

- Much lower bandwidth usage

- Support for much larger video files

- Better privacy by default

I’m a computer engineering student at SPPU. While working on a project with React 19, I realized that the standard libraries we use for SEO (like React Helmet) are still doing things the "old" way.

The Problem: Older libraries use a trick called "side effects" to change your page title and meta tags after the page has already loaded. This can cause the title to flicker or make the site feel a bit slower because the browser has to do extra work.

The Solution: React 19 added a built-in feature that lets it move tags to the top of the page (the <head>) automatically. I built react-meta-seo to make this new feature easy to use for everyone.

Why it’s simpler for developers:

No "Provider" needed: You don't have to wrap your whole app in a special component. It just works wherever you drop it.

Tiny size: It’s under 4KB. For comparison, legacy options are usually 15KB or more.

No more broken Google data: It checks your Google Search data (JSON-LD) automatically to make sure it’s formatted correctly.

Built-in Preview: I added a tool so you can see what your site will look like on Twitter or Facebook while you're still coding.

Simple Sitemap Tool: It includes a command-line tool to make your sitemap.xml for you.

I wanted to build something that used the new React 19 features to make SEO faster and easier to set up. I’d love to get some feedback on the code!

GitHub: https://github.com/ATHARVA262005/react-meta

Posturr is a macOS app that detects poor posture and blurs the screen as a reminder to sit up straight. The app uses machine learning to monitor the user's posture and provides a visual cue to encourage better ergonomics and physical health.

Writeup (includes good/bad sample generations): https://www.linum.ai/field-notes/launch-linum-v2

We're Sahil and Manu, two brothers who spent the last 2 years training text-to-video models from scratch. Today we're releasing them under Apache 2.0.

These are 2B param models capable of generating 2-5 seconds of footage at either 360p or 720p. In terms of model size, the closest comparison is Alibaba's Wan 2.1 1.3B. From our testing, we get significantly better motion capture and aesthetics.

We're not claiming to have reached the frontier. For us, this is a stepping stone towards SOTA - proof we can train these models end-to-end ourselves.

Why train a model from scratch?

We shipped our first model in January 2024 (pre-Sora) as a 180p, 1-second GIF bot, bootstrapped off Stable Diffusion XL. Image VAEs don't understand temporal coherence, and without the original training data, you can't smoothly transition between image and video distributions. At some point you're better off starting over.

For v2, we use T5 for text encoding, Wan 2.1 VAE for compression, and a DiT-variant backbone trained with flow matching. We built our own temporal VAE but Wan's was smaller with equivalent performance, so we used it to save on embedding costs. (We'll open-source our VAE shortly.)

The bulk of development time went into building curation pipelines that actually work (e.g., hand-labeling aesthetic properties and fine-tuning VLMs to filter at scale).

What works: Cartoon/animated styles, food and nature scenes, simple character motion. What doesn't: Complex physics, fast motion (e.g., gymnastics, dancing), consistent text.

Why build this when Veo/Sora exist? Products are extensions of the underlying model's capabilities. If users want a feature the model doesn't support (character consistency, camera controls, editing, style mapping, etc.), you're stuck. To build the product we want, we need to update the model itself. That means owning the development process. It's a bet that will take time (and a lot of GPU compute) to pay off, but we think it's the right one.

What’s next? - Post-training for physics/deformations - Distillation for speed - Audio capabilities - Model scaling

We kept a “lab notebook” of all our experiments in Notion. Happy to answer questions about building a model from 0 → 1. Comments and feedback welcome!

Hey HN! We're Nithin and Nikhil, twin brothers building BrowserOS (YC S24). We're an open-source, privacy-first alternative to the AI browsers from big labs.

The big differentiator: on BrowserOS you can use local LLMs or BYOK and run the agent entirely on the client side, so your company/sensitive data stays on your machine!

Today we're launching filesystem access... just like Claude Cowork, our browser agent can read files, write files, run shell commands! But honestly, we didn't plan for this. It turns out the privacy decision we made 9 months ago accidentally positioned us for this moment.

The architectural bet we made 9 months ago: Unlike other AI browsers (ChatGPT Atlas, Perplexity Comet) where the agent loop runs server-side, we decided early on to run our agent entirely on your machine (client side).

But building everything on the client side wasn't smooth. We initially built our agent loop inside a Chrome extension. But we kept hitting walls -- service worker being single thread JS; not having access to NodeJS libraries. So we made the hard decision 2 months ago to throw away everything and start from scratch.

In the new architecture, our agent loop sits in a standalone binary that we ship alongside our Chromium. And we use gemini-cli for the agent loop with some tweaks! We wrote a neat adapter to translate between Gemini format and Vercel AI SDK format. You can look at our entire codebase here: https://git.new/browseros-agent

How we give browser access to filesystem: When Claude Cowork launched, we realized something: because Atlas and Comet run their agent loop server-side, there's no good way for their agent to access your files without uploading them to the server first. But our agent was already local. Adding filesystem access meant just... opening the door (with your permissions ofc). Our agent can now read and write files just like Claude Code.

What you can actually do today:

a) Organize files in my desktop folder https://youtu.be/NOZ7xjto6Uc

b) Open top 5 HN links, extract the details and write summary into a HTML file https://youtu.be/uXvqs_TCmMQ

--- Where we are now If you haven't tried us since the last Show HN (https://news.ycombinator.com/item?id=44523409), give us another shot. The new architecture unlocked a ton of new features, and we've grown to 8.5K GitHub stars and 100K+ downloads:

c) You can now build more reliable workflows using n8n-like graph https://youtu.be/H_bFfWIevSY

d) You can also use BrowserOS as an MCP server in Cursor or Claude Code https://youtu.be/5nevh00lckM

We are very bullish on browser being the right platform for a Claude Cowork like agent. Browser is the most commonly used app by knowledge workers (emails, docs, spreadsheets, research, etc). And even Anthropic recognizes this -- for Claude Cowork, they have janky integration with browser via a chrome extension. But owning the entire stack allows us to build differentiated features that wouldn't be possible otherwise. Ex: Browser ACLs.

Agents can do dumb or destructive things, so we're adding browser-level guardrails (think IAM for agents): "role(agent): can never click buy" or "role(agent): read-only access on my bank's homepage."

Curious to hear your take on this and the overall thesis.

We’ll be in the comments. Thanks for reading!

GitHub: https://github.com/browseros-ai/BrowserOS

Download: https://browseros.com (available for Mac, Windows, Linux!)

The article describes 'WhoseThere', an open-source project that allows users to view a list of people who have been in their vicinity based on Bluetooth signals from their devices. The project aims to provide a privacy-focused alternative to location-tracking apps, giving users control over their personal data.

jSciPy is an open-source Java signal processing and scientific computing library inspired by SciPy.

It focuses on FFT, filters, PSD, STFT, DCT and Android compatibility, aiming to fill the gap for DSP-heavy workloads on JVM and Android.

Hey HN! This has been my project for a few years now. I recently brought it back to life after taking a pause to focus on my studies.

My goal with this project is to separate fluff from science when shopping for supplements. I am doing this in 3 steps:

1.) I index every supplement on the market (extract each ingredient, normalize by quantity)

2.) I index every research paper on supplementation (rank every claim by effect type and effect size)

3.) I link data between supplements and research papers

Earlier last year, I took pause on a project because I've ran into a few issues:

Legal: Shady companies are sending C&Ds letters demanding their products are taken down from the website. It is not something I had the mental capacity to respond to while also going through my studies. Not coincidentally, these are usually brands with big marketing budgets and poor ingredients to price ratio.

Technical: I started this project when the first LLMs came out. I've built extensive internal evals to understand how LLMs are performing. The hallucinations at the time were simply too frequent to passthrough this data to visitors. However, I recently re-ran my evals with Opus 4.5 and was very impressed. I am running out of scenarios that I can think/find where LLMs are bad at interpreting data.

Business: I still haven't figured out how to monetize it or even who the target customer is.

Despite these challenges, I decided to restart my journey.

My mission is to bring transparency (science and price) to the supplement market. My goal is NOT to increase the use of supplements, but rather to help consumers make informed decisions. Often times, supplementation is not necessary or there are natural ways to supplement (that's my focus this quarter – better education about natural supplementation).

Some things that are helping my cause – Bryan Johnson's journey has drawn a lot more attention to healthy supplementation (blueprint). Thanks to Bryan's efforts, I had so many people in recent months reach out to ask about the state of the project – interest I've not had before.

I am excited to restart this journey and to share it with HN. Your comments on how to approach this would be massively appreciated.

Some key areas of the website:

* Example of navigating supplements by ingredient https://pillser.com/search?q=%22Vitamin+D%22&s=jho4espsuc

* Example of research paper analyzed using AI https://pillser.com/research-papers/effect-of-lactobacillus-...

* Example of looking for very specific strains or ingredients https://pillser.com/probiotics/bifidobacterium-bifidum

* Example of navigating research by health-outcomes https://pillser.com/health-outcomes/improved-intestinal-barr...

* Example of product listing https://pillser.com/supplements/pb-8-probiotic-663

About a month ago, I shared the Day 1 prototype of this project (https://news.ycombinator.com/item?id=46448670). It has since evolved into a somewhat more polished "Slot-Machine Deckbuilder."

I also recently moved the project from qq-pwn.com to alt-qq.com. I did this mid-development specifically to see if I could migrate a live player base and session states without losing people.

The Design Challenge: The core of the game is a "One-Armed Bandit" dungeon crawler. The challenge is balancing the "house always wins" nature of slots with the player agency required for a good roguelike.

What I’d love your feedback on: The First 30 Seconds: Is it immediately obvious how to play? I’ve tried to keep the onboarding "invisible," but I worry the manipulation mechanics might be buried.

Skill vs. Luck: Does the game feel like a mindless gamble, or do you feel like you have agency over the outcome?

The "Cursed Seed" UX: I’ve added a way to share specific runs via a URL. Does the transition from "clicking a friend's link" to "playing the game" feel seamless?

Mobile/PWA Performance: It’s built to be a PWA. Does it feel like a "web page" or does it feel like a native app on your device?

I'm especially interested when and where exactly did you feel like quitting?

Technology: The project is built with React and Vite, hosted on a Cloudflare edge stack. The code is 100% augmented by AI, which allowed me to focus more on the architecture of the project and the design of the mechanics rather than implementation syntax.

Reel Rogue: The Bandit's Tale is playable here: https://alt-qq.com

I built an AI agent that searches the entire Cursor community forum (http://forum.cursor.com/) and answers questions grounded in real forum discussions.

The problem: Cursor's forum has tons of valuable content - feature discussions, troubleshooting threads, tips from power users - but it's hard to search. Traditional forum search is keyword-based and misses a lot of context.

The solution: I indexed the entire forum using Nia (a knowledge indexing service) and connected it to an AI agent with multiple search tools:

- Semantic search - finds relevant posts even when wording differs - Pattern search (grep) - exact matching for error messages, usernames, specific terms - Full thread reading - AI can dive deep into specific discussions - Web search fallback - for questions the forum doesn't cover

GitHub: https://github.com/nozomio-labs/nia-cursor-forum-search

Would love feedback on the approach!

S2 was on HN for our intro blog post a year ago (https://news.ycombinator.com/item?id=42480105). S2 started out as a serverless API — think S3, but for streams.

The idea of streams as a cloud storage primitive resonated with a lot of folks, but not having an open source option was a sticking point for adoption – especially from projects that were themselves open source! So we decided to build it: https://github.com/s2-streamstore/s2

s2-lite is MIT-licensed, written in Rust, and uses SlateDB (https://slatedb.io) as its storage engine. SlateDB is an embedded LSM-style key-value database on top of object storage, which made it a great match for delivering the same durability guarantees as s2.dev.

You can specify a bucket and path to run against an object store like AWS S3 — or skip to run entirely in-memory. (This also makes it a great emulator for dev/test environments).

Why not just open up the backend of our cloud service? s2.dev has a decoupled architecture with multiple components running in Kubernetes, including our own K8S operator – we made tradeoffs that optimize for operation of a thoroughly multi-tenant cloud infra SaaS. With s2-lite, our goal was to ship something dead simple to operate. There is a lot of shared code between the two that now lives in the OSS repo.

A few features remain (notably deletion of resources and records), but s2-lite is substantially ready. Try the Quickstart in the README to stream Star Wars using the s2 CLI!

The key difference between S2 vs a Kafka or Redis Streams: supporting tons of durable streams. I have blogged about the landscape in the context of agent sessions (https://s2.dev/blog/agent-sessions#landscape). Kafka and NATS Jetstream treat streams as provisioned resources, and the protocols/implementations are oriented around such assumptions. Redis Streams and NATS allow for larger numbers of streams, but without proper durability.

The cloud service is completely elastic, but you can also get pretty far with lite despite it being a single-node binary that needs to be scaled vertically. Streams in lite are "just keys" in SlateDB, and cloud object storage is bottomless – although of course there is metadata overhead.

One thing I am excited to improve in s2-lite is pipelining of writes for performance (already supported behind a knob, but needs upstream interface changes for safety). It's a technique we use extensively in s2.dev. Essentially when you are dealing with high latencies like S3, you want to keep data flowing throughout the pipe between client and storage, rather than go lock-step where you first wait for an acknowledgment and then issue another write. This is why S2 has a session protocol over HTTP/2, in addition to stateless REST.

You can test throughput/latency for lite yourself using the `s2 bench` CLI command. The main factors are: your network quality to the storage bucket region, the latency characteristics of the remote store, SlateDB's flush interval (`SL8_FLUSH_INTERVAL=..ms`), and whether pipelining is enabled (`S2LITE_PIPELINE=true` to taste the future).

I'll be here to get thoughts and feedback, and answer any questions!

I want to share Ask CLI, a tool I developed to get help with commands and coding directly from the terminal. It is a simple app designed to do one thing well: provide instant command assistance. This isn't a complex coding agent like Claude Code; it is built specifically to get short, fast answers without context switching.

As a developer, I’ve always struggled to remember every command and its specific options. Whenever I need to use tools like Docker, Git, or psql, I find myself leaving the terminal to check documentation or scrolling through verbose --help text just to recall a specific flag. I usually know what I want to do, but I forget the exact syntax. I didn't want to waste time switching to Google or ChatGPT just to find a one-line command.

I developed Ask CLI to solve this. It has been a game-changer for my workflow. Now, when I forget a command, I simply ask my terminal. It gives me a fast, precise answer—exactly what I need—without breaking my flow.

It is incredibly easy to use: just select an AI model, set your API key, and start chatting naturally with your terminal.

Examples:

$ ask how to run a docker container with env variables

$ ask how to setup my local git account

You can also use the "what" and "how" aliases for a more natural feel:

$ what is chmod

$ how to print all the env variables

You can use Ask CLI with popular hosted models (Gemini, Claude, ChatGPT) or with local models and external providers that support OpenAI-compatible APIs (Ollama, llama.cpp, LM Studio, etc.).

Ask CLI is free and open-source. Check it out here:

https://github.com/david-minaya/ask

I've been building a bitly alternative in public and built a free side tool to upload screenshots to S3. I always thought screenshot apps charged way too much for this so I was pretty happy to get around to build it.

It automatically generates short links and uploads to any S3-compatible storage you own.

Here is the link: https://gofwd.to/screenfwd

Try it out, all feedback is welcome :)

Feedback is appreciated