Show HN for January 14, 2026

hi hn,

i built openwork, an open-source, local-first system inspired by claude cowork.

it’s a native desktop app that runs on top of opencode (opencode.ai). it’s basically an alternative gui for opencode, which (at least until now) has been more focused on technical folks.

the original seed for openwork was simple: i have a home server, and i wanted my wife and i to be able to run privileged workflows. things like controlling home assistant, or deploying custom web apps (e.g. our customs recipe app recipes.benjaminshafii.com), legal torrents, without living in a terminal.

our initial setup was running the opencode web server directly and sharing credentials to it. that worked, but i found the web ui unreliable and very unfriendly for non-technical users.

the goal with openwork is to bring the kind of workflows i’m used to running in the cli into a gui, while keeping a very deep extensibility mindset. ideally this grows into something closer to an obsidian-style ecosystem, but for agentic work.

some core principles i had in mind:

- open by design: no black boxes, no hosted lock-in. everything runs locally or on your own servers. (models don’t run locally yet, but both opencode and openwork are built with that future in mind.) - hyper extensible: skills are installable modules via a skill/package manager, using the native opencode plugin ecosystem. - non-technical by default: plans, progress, permissions, and artifacts are surfaced in the ui, not buried in logs.

you can already try it: - there’s an unsigned dmg - or you can clone the repo, install deps, and if you already have opencode running it should work right away

it’s very alpha, lots of rough edges. i’d love feedback on what feels the roughest or most confusing.

happy to answer questions.

Hi HN,

I built an open-source AI agent that has already indexed and can search the entire Epstein files, roughly 100M words of publicly released documents.

The goal was simple: make a large, messy corpus of PDFs and text files immediately searchable in a precise way, without relying on keyword search or bloated prompts.

What it does:

- The full dataset is already indexed - You can ask natural language questions - Answers are grounded and include direct references to source documents - Supports both exact text lookup and semantic search

Discussion around these files is often fragmented. This makes it possible to explore the primary sources directly and verify claims without manually digging through thousands of pages.

Happy to answer questions or go into technical details.

Code: https://github.com/nozomio-labs/nia-epstein-ai

Hi HN,

My team and I are building Tabstack to handle the "web layer" for AI agents. Launch Post: https://tabstack.ai/blog/intro-browsing-infrastructure-ai-ag...

Maintaining a complex infrastructure stack for web browsing is one of the biggest bottlenecks in building reliable agents. You start with a simple fetch, but quickly end up managing a complex stack of proxies, handling client-side hydration, and debugging brittle selectors. and writing custom parsing logic for every site.

Tabstack is an API that abstracts that infrastructure. You send a URL and an intent; we handle the rendering and return clean, structured data for the LLM.

How it works under the hood:

- Escalation Logic: We don't spin up a full browser instance for every request (which is slow and expensive). We attempt lightweight fetches first, escalating to full browser automation only when the site requires JS execution/hydration.

- Token Optimization: Raw HTML is noisy and burns context window tokens. We process the DOM to strip non-content elements and return a markdown-friendly structure that is optimized for LLM consumption.

- Infrastructure Stability: Scaling headless browsers is notoriously hard (zombie processes, memory leaks, crashing instances). We manage the fleet lifecycle and orchestration so you can run thousands of concurrent requests without maintaining the underlying grid.

On Ethics: Since we are backed by Mozilla, we are strict about how this interacts with the open web.

- We respect robots.txt rules.

- We identify our User Agent.

- We do not use requests/content to train models.

- Data is ephemeral and discarded after the task.

The linked post goes into more detail on the infrastructure and why we think browsing needs to be a distinct layer in the AI stack.

This is obviously a very new space and we're all learning together. There are plenty of known unknowns (and likely even more unknown unknowns) when it comes to agentic browsing, so we’d genuinely appreciate your feedback, questions, and tips.

Happy to answer questions about the stack, our architecture, or the challenges of building browser infrastructure.

For the past year I've been working to rethink how AI manages timing in conversation at Tavus. I've spent a lot of time listening to conversations. Today we're announcing the release of Sparrow-1, the most advanced conversational flow model in the world.

Some technical details: - Predicts conversational floor ownership, not speech endpoints - Audio-native streaming model, no ASR dependency - Human-timed responses without silence-based delays - Zero interruptions at sub-100ms median latency - In benchmarks Sparrow-1 beats all existing models at real world turn-taking baselines

I wrote more about the work here: https://www.tavus.io/post/sparrow-1-human-level-conversation...

wxpath is a declarative web crawler where web crawling and scraping are expressed directly in XPath.

Instead of writing imperative crawl loops, you describe what to follow and what to extract in a single expression:

    import wxpath

    # Crawl, extract fields, build a Wikipedia knowledge graph
    path_expr = """
    url('https://en.wikipedia.org/wiki/Expression_language')
         ///url(//main//a/@href[starts-with(., '/wiki/') and not(contains(., ':'))])
             /map{
                'title': (//span[contains(@class, "mw-page-title-main")]/text())[1] ! string(.),
                'url': string(base-uri(.)),
                'short_description': //div[contains(@class, 'shortdescription')]/text() ! string(.),
                'forward_links': //div[@id="mw-content-text"]//a/@href ! string(.)
             }
    """

    for item in wxpath.wxpath_async_blocking_iter(path_expr, max_depth=1):
        print(item)

The key addition is a `url(...)` operator that fetches and returns HTML for further XPath processing, and `///url(...)` for deep (or paginated) traversal. Everything else is standard XPath 3.1 (maps/arrays/functions).

Features:

- Async/concurrent crawling with streaming results

- Scrapy-inspired auto-throttle and polite crawling

- Hook system for custom processing

- CLI for quick experiments

Another example, paginating through HN comments (via "follow=" argument) pages and extracting data:

    url('https://news.ycombinator.com',
        follow=//a[text()='comments']/@href | //a[@class='morelink']/@href)
        //tr[@class='athing']
          /map {
            'text': .//div[@class='comment']//text(),
            'user': .//a[@class='hnuser']/@href,
            'parent_post': .//span[@class='onstory']/a/@href
          }

Limitations: HTTP-only (no JS rendering yet), no crawl persistence. Both are on the roadmap if there's interest.

GitHub: https://github.com/rodricios/wxpath

PyPI: pip install wxpath

I'd love feedback on the expression syntax and any use cases this might unlock.

Thanks!

I built GRSH because I wanted a modern, memory-safe shell that feels native to FreeBSD but works seamlessly on macOS.

While there are many shells out there, GRSH is my take on a minimal, fast, and secure command interpreter written entirely in Rust. It's designed for users who want the safety guarantees of Rust without the overhead of more bloated alternatives.

I'm currently working on the official FreeBSD port. I’d love to get feedback on the shell's behavior and performance from the community.

Github: https://github.com/antoniomalara301289/grsh

Hi Everyone,

Digital Carrot is a programmable and pluggable app blocker. It lets you block websites and apps on iOS, Mac and Windows until a set of conditions or goal is met. For example you can block Reddit, Instagram and Steam until your Apple Watch reports that you have walked 5000 steps.

The app works by collecting data via plugins that you can use to create goals for yourself. Goals are all represented by expressions that return true or false based on the data you provide. For example, if you want to create a goal to finish all of the tasks in your to-do list you could do something like `data.apple_reminders.due == 0`.

The blocking system is also pluggable. That means you can block items via DNS with services as Pi-hole[3]. It also means that the app is not just limited to website blocking! In fact you could write a plugin to control anything that is available via a REST, such as locking a smart lock on your snack cupboard or cranking up the AC in your office until you go outside.

Keeping security and user privacy is a top priority for this app (given that it's literally designed to collect information about you). Because of that:

- We do not collect or share any information that the app gathers. - Our sync feature is fully end to end encrypted using AES256 and the secure remote password protocol. - All plugins are sandboxed. They cannot access data provided by other plugins and have no external access unless granted by the user. - The app is transparent about the data it has. All of the data that is available to use for goals is browsable in app.

Like many of you, I've been dismayed by big tech's lack of concern for our privacy, so keeping these guarantees is personally very important to me. One of the fun things about this project has been that I can kind of flip the script by taking all of the information that has been gathered about me and use it to help cut down on the distractions in my life :)

Anyway, I had to walk 4km to unblock HN in order to post this, so I hope you find it helpful!

[1] Technical overview: https://www.digitalcarrot.app/docs/overview/

[2] Plugin repository: https://github.com/digital-carrot-app/plugins

[3] Pi-hole plugin: https://github.com/digital-carrot-app/plugins/tree/main/piho...

Hi HN, my name's Clifford and I'm one of the creators of Nori. I’ve been using Claude Code heavily since last summer, and after understanding some of the tradeoffs with their TUI implementation, I knew I couldn't see myself living for years with this interface as one of my daily-driver tools.

It is not a hard problem to make monospace text output performant, so why does Claude Code suffer from flicker and strobing in the terminal (https://github.com/anthropics/claude-code/issues/1913)? Even after they've released multiple improvements for this, I still see the issue in terminal splits with fewer rows, or in less performant emulators, and even within a virtual TTY (the absolute simplest environment to run an interactive program in). After digging in throughout the past half year, the issue is mostly inevitable because Claude reprints full terminal history without using alt screen mode and uses a React-based framework (Ink) to render and style their text. That's great for JS+CSS being "on distribution" for LLMs in order to vibecode the continued development of Claude Code, but it doesn't deliver the experience I'd like. The frameworks they've chosen also have limitations around [terminal input parsing (i.e. the shift enter issues from last year: https://github.com/anomalyco/opencode/issues/1505#issuecomme...). Great terminal interfaces I've lived with for years (neovim, btop, helix, Cataclysm DDA, etc) don't sacrifice user experience as a tradeoff for development convenience. They build resilient terminal interfaces on languages more appropriate for this problem, like C or C++ or Rust.

Finally, while I'm definitely rooting for Anthropic to continue improving their products, I can't see myself coupling a commandline tool I use often with a single LLM provider. It would be insane if pushing my code to GitHub required me to edit it in VSCode — I want my tooling to do one thing well, and that's display the read-eval-tool-loop from talking to an agent. Opus 4.5 has been stellar, but it's nonnegotiable to me that I can try out varied providers with the same tools I plan to use everyday. Claude Code will not be working long term on how best to interface with multiple agents, from varying providers, in one terminal pane, and that makes perfect sense for their business. However based on our other experiences building out profiles and skillsets for agents, deeper customizations of agent instructions and subagents, and parallel worktrees for local agents, we have a lot of vision for how to handle local agentic work. And with the current design to integrate at the agent-level, we don't plan on working around the OAuth flows or spoofing the system prompt outside of the Claude Code SDK (like with the OpenCode situation), and risk the tools coming into conflict with the providers.

These were the main considerations that went into designing Nori CLI. It's a very thin and very fast TUI wrapper around multiple agent providers. It integrates with providers at the agent level, instead of the model level. Not only does that provide better performance in our experience, but that is also *compliant with current ToS for subscription based usage.* This is a very early version, but given the timing this week it might give you a flicker-free way to code with Claude Code!

The project is open source, and built on the stellar work by folks at Zed (on the abstraction over varied coding agents), and the folks working on Codex CLI (who have put together one of the nicest proprietary terminal experiences).

I'm very curious: What are the Claude Code features you couldn't give up, to make the switch to a tool like this? What are the Claude Code features that work as intended, but you can't stand?

hi my name is sean dorje (yc x25).

i built harmony because our team's been running on discord for years and we've been dying for something like this so we can finally track our meeting notes/action items.

if your team runs on discord, please feel free to try it out!

it's free to use forever :)

I built an unofficial CLI and MCP server for Lambda cloud GPU instances.

The main idea: your AI agents can now spin up and manage Lambda GPUs for you.

The MCP server exposes tools to find, launch, and terminate instances. Add it to Claude Code, Cursor, or any agent with one command and you can say things like "launch an H100, ssh in, and run big_job.py"

  Other features:
  - Notifications via Slack, Discord, or Telegram when instances are SSH-ready
  - 1Password support for API keys
  - Also includes a standalone CLI with the same functionality

Written in Rust. MIT licensed.

Note: This is an unofficial community project, not affiliated with Lambda.

I've been looking for a way to run LLMs safely without needing to approve every command. There are plenty of projects out there that run the agent in docker, but they don't always contain the dependencies that I need.

Then it struck me. I already define project dependencies with mise. What if we could build a container on the fly for any project by reading the mise config?

I've been using agent-en-place for a couple of weeks now, and it's working great! I'd love to hear what y'all think

Hey HN! I’m Ashwin, co-founder of ContextFort (https://contextfort.ai/). We provide visibility and controls for AI browser agents like Claude in Chrome through an open-source browser extension.

Browser agents are AI copilots that can autonomously navigate and take actions in your browser. They show up as standalone browsers (Comet, Atlas) or Chrome extensions (Claude).

They’re especially useful in sites where search/API connectors don’t work well, like searching through Google Groups threads for a bug fix or pulling invoices from BILL.com. Anthropic released Claude CoWork yesterday, and in their launch video, they showcased their browser-use chromium extension: https://www.youtube.com/watch?v=UAmKyyZ-b9E

But enterprise adoption is slow because of indirect prompt injection risks, about which Simon Willison has written in great detail in his blogs: https://simonwillison.net/2025/Aug/26/piloting-claude-for-ch.... And before security teams can decide on guardrails, they need to know how employees are using browser agents to understand where the risks are.

So, we reverse-engineered how the Claude in Chrome extension works and built a visibility layer that tracks agent sessions end-to-end. It detects when an AI agent takes control of the browser and records which pages it visited during a session and what it does on each page (what was clicked and where text was input).

On top of that, we’ve also added simple controls for security teams to act on based on what the visibility layer captures:

(1) Block specific actions on specific pages (e.g., prevent the agent from clicking “Submit” on email)

(2) Block risky cross-site flows in a single session (e.g., block navigation to Atlassian after interacting with StackOverflow), or apply a stricter policy and block bringing any external context to Atlassian entirely.

We demo all the above features here in this 2-minute YouTube video: https://www.youtube.com/watch?v=1YtEGVZKMeo

You can try our browser extension here: https://github.com/ContextFort-AI/ContextFort

Thrilled to share this with you and hear your comments!

I wanted to find an iPad game where my 5yo could learn math, which sounded simple.

Turns out most kids' educational apps are... shady. Notifications, streak mechanics, ads for games definitely not meant for children, coin systems and flashy rewards designed to maximize engagement rather than learning.

So I decided to vibe code something for her.

The result is Lumi. It's a simple math app with: - No ads, no accounts, no tracking - No notifications - No coins, streaks, or variable reward nonsense - Daily limits (because kids should go play outside) - Works offline, stores everything locally - Supports English, Portuguese, German, French (more to come)

My daughter has been using it for a while now and actually enjoys it. The problems adapt to her level, and when she hits the daily limit, it just tells her to go do something else.

It's completely free and open source. I built it for her, but figured other parents might find it useful too.

https://playlumi.app/ https://github.com/matheusml/lumi

Happy to answer questions about the tech stack (SvelteKit, TypeScript), decisions, or anything else

I found myself frequently wanting to schedule tasks in Claude Code (both one-time and recurring) so I built a CC plugin to help with that.

To install: /plugin marketplace add jshchnz/claude-code-scheduler /plugin install scheduler@claude-code-scheduler

Then just tell Claude what you want (some examples):

Every Wednesday at 3am find dead code: unused functions, unreachable branches, commented-out code, and unused imports. List by file with line numbers.

Schedule a code review every weekday at 9am. Review commits from the last 24 hours, check for bugs, security issues, error handling gaps, and code that needs comments. Summarize with file:line references.

Hey!

I'm Ali, and I built a tool to help me learn Spanish. There's a good amount of info in the about page, but the short version is that I found apps like Duolingo completely useless. In theory they're designed to help you speak a language but I found it mostly helped my muscle memory tap the right parts of a screen without really learning to say anything. Or more importantly prepare me for how fast a native Spanish speaker speaks!

After giving up on Duolingo I tried a few different things; Pimsleur, Paul Noble and Language Transfer. These are all great in different (but similar) ways and after listening to them in the car for a few months, the next time I went to Spain I was able to hold (very) basic conversations and even book a table at a nearby restaurant over the phone without saying a single word of English.

I also tried ISSEN (a YC startup I saw posting here that advertises itself as an AI language tutor) and found it to be... underwhelming. It spoke at much too high a level for me and I think asked me about pets or something? When I said I didn't have a dog it completely ignored that and asked what breed of dog it was. I've used a few different "voice-native" AI agents and even the ones in English left a lot to be desired in terms of interruptions, understanding and memory. It also doesn't help with the one time in my life that I actually have time to learn Spanish, which is when I'm driving my car.

So I decided to try and recreate the Language Transfer/Paul Noble style learning approach, but letting you write an AI prompt to create a lesson suited to your interests and learning level.

https://cadencespanish.com/

Any feedback would be great!

In terms of tech stack, I used Lovable and Supabase. I wrote some of the copy by hand but none of the code. I use ElevenLabs for the realtime speech-to-text and Google Cloud for the text-to-speech (it's an awful lot cheaper and sounds quite good). I am a software developer (I work for a totally unrelated YC backed startup) but I've somewhat fallen in love with Lovable for how fast I can go from "huh, I wonder if this would work" to something in production. And ironically I learned the most about React and react-router-dom from a previous time when Lovable built something that went so wrong I had to dig into the code and rewrite bits of it.

Most of us have a list of URLs we need data from (government listings, local business info, pdf directories). Usually, that means hiring a freelancer or paying for an expensive, rigid SaaS.

We built an AI Web Agent platform, rtrvr.ai to make "Vibe Scraping" a thing.

How it works:

1. Upload a Google Sheet with your URLs.

2. Prompt: "Find the email, phone number, and their top 3 services."

3. Watch the AI agents open 50+ browsers at once and fill your sheet in real-time.

It’s powered by a multi-agent system that can take actions, upload files, and crawl through paginations.

Web Agent technology built from the ground up:

End to End Agent: we built a resilient agentic harness with 20+ specialized sub-agents that transforms a single prompt into a complete end-to-end workflow. Turn any prompt into an end to end workflow, and on any site changes the agent adapts.

Dom Intelligence: we perfected a DOM-only web agent approach that represents any webpage as semantic trees guaranteeing zero hallucinations and leveraging the underlying semantic reasoning capabilities of LLMs.

Native Chrome APIs: we built a Chrome Extension to control cloud browsers that runs in the same process as the browser to avoid the bot detection and failure rates of CDP. We further solved the hard problems of interacting with the Shadow DOM and other DOM edge cases.

Cost: We engineered the cost down to $10/mo but you can bring your own Gemini key and proxies to use for nearly FREE. Compare that to the $200+/mo some other lead gen tools like Clay charge.

Use the free browser extension for login walled sites like LinkedIn locally, or the cloud platform for scale on the public web.

We are thinking it can be a great upstream tool to your CRM to generate lists and enrich data.

Curious to hear if this would make your lead generation, scraping, or automation easier or is it missing the mark?

I got tired of: - .env files committed to Git (seen it happen 100+ times) - API keys shared in Slack - Wondering who has access to what secrets

So I built Liberty - a CLI tool that replaces .env files with hardware-bound encryption.

How it works:

  $ pip install liberty-secrets
  $ liberty add DATABASE_URL postgresql://...
  $ liberty add STRIPE_KEY sk-...
  $ liberty exec npm start

Secrets are encrypted with a key derived from your machine's hardware (CPU ID + machine ID + disk serial). If someone steals your .liberty vault file, it's useless on their machine.

Features:

  - Hardware-bound AES-256-GCM encryption
  - Complete audit trail (compliance-ready)
  - Works offline (no servers, no accounts)
  - Global vault (~/.liberty/ works from any directory)
  - MIT licensed, free for individual use

GitLab: https://gitlab.com/deciphergit/liberty

PyPI: https://pypi.org/project/liberty-secrets/

Team features (secret sharing) coming soon as paid tier.

Feedback welcome!

Hi HN, we built this.

The NBA Edge Index uses pre-game win probabilities from Polymarket (real-money prediction markets). After each game finalizes, we compare the outcome to the pre-game odds. Beating expectations moves a team's rating up; underperforming moves it down. Each team starts at 2000, and ratings accumulate game-by-game throughout the season. Updates happen automatically after games finalize.

A few data points we found interesting:

Polymarket odds are pretty accurate on average: teams priced at 80%+ won 82% of the time (119 games), and teams priced 60–69% won 63%.

Biggest overperformer: Phoenix Suns, +14.7% vs expectations (market gave them 45.8% avg odds; they won 60.5%).

Most overrated by market: Cleveland Cavaliers — 55.8% win rate but market gave them 67.4% implied. They've lost 12 games as heavy favorites.

Biggest called upset: Utah Jazz beat Cleveland on Jan 13 with 18.5% market odds; our edge model gave Utah 70.9%.

Stability: After ~40 games per team, rankings start to diverge meaningfully and early noise smooths out.

We're working on more indices like this. The core idea: prediction market data is fragmented across hundreds of contracts that expire and disappear. We turn it into persistent, trackable indices.

Two patterns we use:

Composite — Blend related markets into one number. Our Global Conflict Risk Index combines ~15 Polymarket contracts (Ukraine, Taiwan, Iran) into a single number.

Rolling — Auto-replace expiring contracts. For example our weather indices track 6-city temperature deviations by rolling forward daily.

Curious to hear feedback or suggestions of ideas for other indices.

The live NBA Edge index is here: https://attena.xyz/nba

Hey all,

This is a project I’ve been working on over the last year.

In addition to combining data from multiple federal sources into a single UI, I built a 2,500+ rule regex-based parser / pseudo state machine that classifies every legislative action into discrete states and stages. This makes it possible to generate a day-by-day timeline of what happened to every bill over the last 50 years, and a graph showing how many (and which) bills occupy each major legislative state at any point in time. In total, 1,555,069 actions are parsed into 1,157 unique enums across 41 stages.

I also fully re-parsed the official bill text XML into a modern format and recreated the large bill-text XLS styling system in CSS, which dramatically improves load times and (to my knowledge) is the first near-complete recreation of that XLS styling in CSS.

Hope you find it interesting :)

I built this Chrome extension to solve my daily RAM problem. Chrome was constantly eating 8-10GB of memory with all my open tabs.

Smart Tab Suspender automatically suspends tabs you haven't used in a while, freeing up memory without closing them. Click back on a suspended tab and it instantly reloads.

Key features: - Auto-suspend after configurable idle time - Whitelist for important tabs - Manual suspend/unsuspend options - No data collection or tracking

On my machine with 50+ tabs, it reduced Chrome's memory usage by ~60%.

The extension is free and open to feedback. Let me know if you have suggestions or find any issues!

We built a product that can take in text to describe your circuit and generate the electronics for you in minutes. Reach out to [email protected] so I can send you our product to try out.

Hey HN,

I had Mac Minis sitting in the corner doing nothing and a laptop battery that tanks whenever I run tests when working from a coffee shop & on battery power. So I built a CLI that syncs code over SSH and runs commands remotely on my (usually) idle hardware. That's basically it.

``` brew install rileyhilliard/tap/rr rr run "make test" ```

Where this got surprisingly useful: heavy TDD with Claude Code. When you're running swarm agents or sub-agents, they all want to run tests constantly to verify their work. Great in theory, but suddenly you've got 3-4 parallel processes all hammering your test suite at once on your laptop. Tests fail because they're stomping on each other, ports are already in use, your laptop is melting, etc.

rr handles the coordination automagically. It tries your LAN IP first, falls back to Tailscale when you're remote, and waits if someone else (which is probably you in another terminal) is already using the machine. Throw multiple hosts at it and it'll load balance across whatever's available.

``` hosts: mini-1: ssh: - 192.168.1.50 - mini1-tailscale mini-2: ssh: - 192.168.1.51 - mini2-tailscale ```

The parallel execution part is where it gets quite nice. My test suite takes ~60s on one machine. Partitioned across three, it finishes in ~20s. Same tests, 3x faster. Agents checking work via TDD stay productive instead of sitting around waiting.

This isn't really a CI/CD thing (that's async, runs when you push). rr is for your active dev loop when you want results NOW so you can keep iterating.

Any hardware that holds an SSH connection works. Old laptops, cloud boxes, whatever. Minimal setup on the remote side.

https://github.com/rileyhilliard/rr

Hi everyone,

Repomance is an app for discovering curated and trending repositories. Swipe to star them directly using your GitHub account. It is currently available on iOS, iPadOS, and macOS. I plan to develop an Android version once the app reaches 100 users.

Repomance is open source: https://github.com/mpospirit-apps/Repomance-iOS

All feedback is welcome, hope you enjoy using it.

I’m a solo developer and I just launched Beam, a desktop-style browser for iPad.

Most iPad browsers still feel like stretched phone apps. Beam was built to feel closer to a real desktop productivity browser, with features like:

- Persistent sidebar with vertical tabs - Spaces, favourites and pinned tabs - Command bar and full keyboard shortcut support - Memory-efficient tab lifecycle (active, warm, suspended tabs) - Desktop-grade tab management designed specifically for iPad hardware limits

A big part of the work went into managing web views efficiently. iPads have much tighter memory constraints than desktops, so Beam unloads inactive tabs while keeping switching between active ones instant.

It’s a paid app ($4.99) with no subscriptions, no accounts, and no tracking beyond basic anonymised usage metrics.

App Store link: https://apps.apple.com/us/app/beam-browser/id6756218494

I’d really appreciate any feedback, especially from people who use iPads heavily with keyboards.

Happy to answer questions.

More info: beambrowser.app

Hey HN, I built Lore because I was frustrated with context loss when using AI coding agents.

Git tells you who changed code and when. Comments (hopefully) tell you what the code does. But neither captures why it was written that way, the reasoning, the alternatives that were rejected, the trade-offs considered. Would love feedback on the approach.

Website: https://avraammavridis.github.io/lore/

GitHub: https://github.com/avraammavridis/lore

Hello HN,

I’m David. I built Matriq because I was frustrated with the "Post-Production Scrub."

I had hours of B-roll and long-form content, but finding a specific 5-second clip (e.g., "a red car passing by" or "a specific quote about React state") meant manually watching the footage at 2x speed.

What I built: Matriq indexes video content visually and aurally. It uses multimodal embeddings to understand scene context, action, and dialogue.

The Use Case:

While it works for general editing, I’ve found the best use case is Content Repurposing. Creators with 100+ hours of archives can now instantly find "viral hooks" or specific topics to turn into Shorts/Reels without re-watching old footage.

It’s in beta. I’d love you to try breaking it or give feedback on the retrieval accuracy.

Link: https://matriq.video

A Chrome extension that removes algorithmically-driven "For You" sections and distracting navigation elements from popular websites.

If you use Rust and want to learn about the Lettre crate for sending email using SMTP, here's a simple demonstration that can help with Lettre SMTP diagnostics and troubleshooting.

Feedback welcome, especially how to make it even easier for newcomers to diagnose SMTP issues. This code is all hand coded, no AI.

There are three implementations: synchronous, asynchronous with tokio1 rustls tls, asynchronous with tokio1 native tls.

https://github.com/joelparkerhenderson/demo-rust-lettre-sync

https://github.com/joelparkerhenderson/demo-rust-lettre-async-tokio1-rustls-tls

https://github.com/joelparkerhenderson/demo-rust-lettre-async-tokio1-native-tls

Hi HN! I’m excited to share Tizo, a lightweight web tool that makes time zone conversions and global time tracking friction-free.

I built Tizo to help anyone who deals with multiple time zones — whether you’re scheduling meetings across continents, planning travel, or coordinating with teammates around the world. Too often time zone tools are clunky or overloaded with features; Tizo strips everything down to the essentials:

Instant time zone conversions between any two regions

Current time display for any selected zone

Multiple date & time formats supported

Responsive and easy to use on desktop or mobile

Whether you’re a remote worker, traveler, or just juggling international friends, Tizo helps eliminate confusion and saves you a bunch of mental math. It’s free and web-based — no install, no signup.

I’d love to hear how you use it and what else would make it even more useful.

— Elston (Maker of Tizo)

Hi HN,

I’m an indie developer and I recently shipped my first iOS app, PhotoCraft. It’s an AI-powered photo editor focused on enhancement, avatars, and creative edits.

This project started mainly as a way for me to learn how to take an idea all the way from development to passing App Store review and shipping something real. The hardest parts for me weren’t the models or the UI, but scope control, onboarding decisions, and dealing with review feedback.

A few things I learned along the way:

“Good enough to ship” is harder to define than expected

App Store rejections are more about clarity and UX than code

Cutting features early saved me a lot of time later

I’m sharing this mostly to get feedback from people who’ve built and shipped products before. I’d especially appreciate thoughts on:

First-time user experience

Whether the feature set feels focused or bloated

Monetization flow (what feels fair vs frustrating)

Happy to answer any questions about the build, tooling, or App Store review process.

Thanks for taking a look.

— Deva

I rewrited slsqp solver in rust with help of vibe coding. No harm to create a wasm demo.

Hi HN! I, Tom, am a founder of hirebetter and I’d love to share what we’ve been working on and get feedback from the community.

hirebetter is a set of AI-driven tools designed to take over repetitive manual tasks that recruiters and solo founders often face when hiring. At a high level, it helps with things like drafting outreach messages, filtering candidate profiles, and generating tailored interview prompts, all with the goal of saving time and making the hiring process consistent across candidates.

My co-founders have spent years in recruiting and hiring for small teams, and found themselves constantly doing the same manual work — customizing templates, digging through resumes, juggling tabs and tools. A lot of that felt like busy work that could be automated intelligently, so I started building hirebetter to fill that gap.

The current tools are: Job Description, Candidate Summary, Interview Questions, Job Ad Rewriter, Position Benchmarking, Social Media Job Posts (with Image), Outreach Messages, Infopack, Hiring Process, Boolean Search, Candidate Persona, Job Board Suggestions & Rejection Letter.

We’re thinking of working on a Google Chrome extension so you can use hirebetter's tools directly while browsing LinkedIn, job boards, or applicant trackers, without switching tabs. The extension will bring this functionality right where you already work.

The product is live at the link above. We’d love to hear:

   - What’s confusing or unclear?
   - What tasks in hiring do you hate the most?
   - How would you use something like this in your workflow?

Happy to answer any questions and iterate based on your feedback!

I wrote this to describe an execution model where recovery is enforced locally instead of inferred from history. Rather than retries replay or coordination each unit admits or rejects state and input pairs and resets immediately when constraints are violated. Recovery cost is constant failures do not correlate and tail latency never forms because there is no recovery negotiation. This is not about availability theater or smarter retries but about refusing to remain broken.

I’ve been working on a small, design-first async bulkhead for Java.

It focuses strictly on admission control: – bounds in-flight async operations – fails fast under saturation – never queues or waits – defines permit lifetime explicitly (admitted → terminal)

v0.3.1 is a small patch release that fixes cancellation classification in observability (wrapped CancellationException is now reported as CANCELLED), without changing runtime behavior.

I’m interested in feedback from people who’ve dealt with overload, fan-out amplification, or unclear async semantics in Java systems.

My attempt at the Riemann Hypothesis. Builds on my P does NOT Equal NP Paper & Lean 4 formalization.

Check the Zenodo DOI for all ten artifacts/supplementary evidence.