The word processor engine and rendering layer are all built from scratch - the only 3rd party library I used was the excellent Y.js for the CRDT stack.
Would love some feedback!
In Refrax, the browser I built, both windows show the same page updating live. The same web page, in as many windows as you want.
This shouldn't be possible. WebKit's WKWebView can exist in exactly one view hierarchy at a time. With macOS 26, Apple added a SwiftUI API separating WebView from WebPage, so you can end up with multiple views referencing the same page. But if you try it, your app crashes. WebKit source code has a precondition with this comment: "We can't have multiple owning pages regardless, but we'll want to decide if it's an error, if we can handle it gracefully, and how deterministic it might even be..."
So here's how I did it.
CAPortalLayer is an undocumented private class that's been in macOS since 10.12. It mirrors a layer's composited output by referencing the same GPU memory, not copying it. Every scroll, animation, or repaint reflects instantly. This is what powers Liquid Glass effects, the iOS text selection magnifier, and ghost images during drag and drop. Apple uses portals for effects. I use them to put the same web page in two windows.
Refrax keeps one real WKWebView per tab and displays a CAPortalLayer mirror everywhere else. When you click a different window, the coordinator moves the real view there and the old window gets a portal. You can't tell which is which.
This sounds simple in theory, but making this actually work seamlessly took quite a lot of effort. Each macOS window has its own rendering context, and the context ID updates asynchronously, so creating a portal immediately captures a stale ID and renders nothing. The portal creation needs to be delayed, but delaying creates a visual gap. I capture a GPU snapshot using a private CoreGraphics function and place it behind the portal as a fallback. Another hard part is that none of it is documented. Portals are very capricious and would crash the app if you use them incorrectly. I had to inspect the headers and then disassemble the binaries to explore exactly how it works in order to build something robust.
I never worked on a browser before this, I've only been a user. I started using Arc in 2022. I remember asking for an invite, learning the shortcuts, slowly getting used to it. I didn't like it at first as it had too much Google Chrome in it for my taste, and I'd been using Safari at the time. But it grew on me, and by the time it was essentially abandoned and sold to Atlassian, I couldn't go back to Safari anymore. I tried everything: Zen, SigmaOS, Helium. None felt right, and I didn't want another Chromium fork. WebKit ships with the OS, but all you get is the rendering engine. Tabs, history, bookmarks, passwords, extensions, everything else has to be made separately. And so, being a very reasonable person, I decided to make my own Arc replacement from scratch.
And I did. Refrax is built in Swift and Objective-C with no external dependencies. The app itself is less than 30 MB. I have 393 tabs open right now using 442 MB of RAM; 150 tabs in Safari was already over 1 GB. I've been using it daily for over a month, and so have some of my friends.
The portal mirror is just one feature. The same approach, finding what Apple built for themselves and using it to create something they didn't think about, runs through the entire browser. You can tint your glass windows with adjustable blend modes and transparency. The sidebar in compact mode samples the page and matches the colors. And it has support for Firefox and Chrome extensions.
The alpha is public. Download from the linked website, enter REFRAX-ALPHA-HACKERNEWS to activate. No account needed. Telemetry is crash reports and a daily active-user ping, nothing else. And if you find a bug – I built this alone, so I'll actually read your report.
The concept: programming languages exist because machines couldn't understand human intent. LLMs can. So what happens if you remove the code entirely and just... describe what each function should do?
The tool replaces functions one by one, runs your test suite after each swap to confirm nothing breaks, and outputs a .md file. Then `tril run` spins up an HTTP server that sends each function's English description to Claude and returns the result.
Tested on a unit converter (JS) and a 625-line Python CLI tool — tests passed, results matched to 6 decimal places (fortunately).
This is mainly a thought experiment: can any code become plain natural language? Will it still work? Let's find out!
npm: ``` npx @sliday/tril convert https://github.com/your/repo ```
GitHub: https://github.com/sliday/tril
Key Technical Highlights:
Zero Dependencies: Just the Windows API
Performance: Starts in 0.1ms on a twelve year old machine. It handles projects with 500k+ lines without UI lag or indexing stutters.
Integrated Tools: Includes a custom-built debugger, profiler, and Intellisense engine designed for speed.
Portability: It’s a single executable. No installer required.
I built this because I was tired of waiting 10 seconds for Visual Studio to "wake up" and seeing my RAM disappear just to boot it up. It’s currently hosted on itch.io while I gather funds to set up a dedicated site.
This is fully AI-coded, researched, and sourced.
Additionally, AI helped develop the scoring system. The evidence gathering is done by a number of different agents through OpenRouter that gather and classify source-backed claims. The point of that is not to pretend bias disappears, but to avoid me manually selecting the evidence myself. I intend for it to remain current and grow. The system is close to fully automated, though ongoing evidence collection at scale is still limited mostly by cost.
The name is an homage to the early days of Web 1.0 and Hot or Not, which was a main competitor of mine as the creator of FaceTheJury.com, but I think it works well here.
The backend and frontend are running on Cloudflare Workers with D1. It's coded in vanilla JavaScript.
You can zoom into any period - some patterns are surprisingly clear (AI overtaking startup culture as HN's top topic, crypto's rise and fall, remote work spiking with COVID).
Happy to answer questions about the methodology.
The retrieval architecture is a Frankenstein, which is pretty much always my process. I pulled the best parts from recent projects and research and stitched them together: [QMD](https://github.com/tobi/qmd) for the multi-signal retrieval pipeline (BM25 + vector + RRF + query expansion + cross-encoder reranking), [SAME](https://github.com/sgx-labs/statelessagent) for composite scoring with content-type half-lives and co-activation reinforcement, [MAGMA](https://arxiv.org/abs/2501.13956) for intent classification with multi-graph traversal (semantic, temporal, and causal beam search), [A-MEM](https://arxiv.org/abs/2510.02178) for self-evolving memory notes, and [Engram](https://github.com/Gentleman-Programming/engram) for deduplication patterns and temporal navigation. None of these were designed to work together. Making them coherent was most of the work.
On the inference side, QMD's original stack uses a 300MB embedding model, a 1.1GB query expansion LLM, and a 600MB reranker. These run via llama-server on a GPU or in-process through node-llama-cpp (Metal, Vulkan, or CPU). But the more interesting path is the SOTA upgrade: ZeroEntropy's distillation-paired zembed-1 + zerank-2. These are currently the top-ranked embedding and reranking models on MTEB, and they're designed to work together. The reranker was distilled from the same teacher as the embedder, so they share a semantic space. You need ~12GB VRAM to run both, but retrieval quality is noticeably better than the default stack. There's also a cloud embedding option if you'd rather not run models locally at all.
For Claude Code specifically, it hooks into lifecycle events. Context-surfacing fires on every prompt to inject relevant memory, decision-extractor and handoff-generator capture session state, and a feedback loop reinforces notes that actually get referenced. That handles about 90% of retrieval automatically. The other 10% is 28 MCP tools for explicit queries. For OpenClaw, it registers as a ContextEngine plugin with the same hook-to-lifecycle mapping, plus 5 REST API tools for the agent to call directly.
It runs on Bun with a single SQLite vault (WAL mode, FTS5 + vec0). Everything is on-device; no cloud dependency unless you opt into cloud embedding. The whole system is self-contained.
This is a polished WIP, not a finished product. I'm a solo dev. The codebase is around 19K lines and the main store module is a 4K-line god object that probably needs splitting. And of course, the system is only as good as what you index. A vault with three memory files gives deservedly thin results. One with your project docs, research notes, and decision records gives something actually useful.
Two questions I'd genuinely like input on: (1) Has anyone else tried running SOTA embedding + reranking models locally for agent memory, and is the quality difference worth the VRAM? (2) For those running multiple agent interfaces (CLI + voice/chat), how are you handling shared memory today?
As far as I know, there's no widely available tool that does this end to end. The closest things are academic projects or ImageJ, which is more of a general purpose image processor without automatic particle detection. Nanostat handles the detection, measurement, and visualization in one place.
Posting here on the off chance that there are microscopists that may be open to trying it out and giving some feedback. There's a live demo on the homepage with real electron microscopy data, where you can interact with the full workflow (eraser, overlays, histograms, metrics, etc.) without signing up. If you want to try your own images, there's a free tier
I like keeping Activity Monitor in my dock, but the default icon always felt off. It technically shows activity, but visually it doesn’t feel like it belongs in macOS — more like a raw canvas than a proper system icon.
So I rebuilt it.
Same app, same data — just a dock icon that looks and behaves like a native macOS component, with a clean, readable CPU graph.
No new features, just fixing how it looks and feels.
Curious if others noticed this too, or if it never bothered you.
Rather than declaring what music is, FoM shows where and how music becomes possible.
It provides simple explanations to complex concepts like vibrato, glissando, and portamento to outsiders.
It enables new vocabulary like jazzing, jazzing aroung, jazzing along, and jazz translation which are mind refreshing, at least to me.
For a sample of translation (Turkish Folk to Blues) you may see: https://www.youtube.com/watch?v=Ml4pEk2hMM8
Proposed perceptual fatigue concept can be found highly controversial, but I think it may be an inspiring food for thought.
In the end, FoM is a work in progress to constitute a stable ground from which new musical questions can be meaningfully explored.
I built Daily Reflections because I wanted a journaling space that was actually private—no accounts, no cloud, and no "SaaS-ification" of my personal thoughts.
The Implementation:
Vanilla Stack: 100% pure HTML, CSS, and JavaScript. No build step, no frameworks, no external libraries.
Local-First: Everything lives in localStorage. 0% of your data is transmitted to a server.
Data Portability: Since it's local-only, I added JSON backup/import and a monthly PDF export to ensure the user actually owns their data.
Visualization: I used the Canvas API for mood trend charts and a GitHub-style consistency heatmap to keep the footprint tiny.
Offline-First: It's a PWA with a service worker, so it works perfectly in airplane mode.
The "Then vs. Now" Feature: I wanted to solve the "write and forget" problem. The app automatically resurfaces entries from exactly 1 week, 1 month, or 1 year ago to provide immediate perspective on personal growth.
I'm using this as my primary journal now. I’d love to hear your thoughts on the local-first approach and any performance concerns regarding localStorage for long-term text storage.
I built Butterwell after watching too many bakers sell things at a loss because pricing felt like guesswork.
The pattern I kept seeing: someone makes a great product, they pick a price based on what "feels right," and they never account for ingredient cost fluctuations or their own time. Most don't want to touch a spreadsheet.
Butterwell lets you photograph your recipe — handwritten or typed — and uses AI to detect the ingredients. It then pulls live grocery prices and calculates what you should charge, with a breakdown showing ingredient cost, labor, and margin.
The live price data was the tricky part to get right. Grocery prices shift constantly and the gap between stale data and real data meaningfully changes the recommended price.
Currently in free beta. Curious what the HN crowd thinks about the pricing model approach.