Top stories

Creator here. I built ChartGPU because I kept hitting the same wall: charting libraries that claim to be "fast" but choke past 100K data points.

The core insight: Canvas2D is fundamentally CPU-bound. Even WebGL chart libraries still do most computation on the CPU. So I moved everything to the GPU via WebGPU:

- LTTB downsampling runs as a compute shader - Hit-testing for tooltips/hover is GPU-accelerated - Rendering uses instanced draws (one draw call per series)

The result: 1M points at 60fps with smooth zoom/pan.

Live demo: https://chartgpu.github.io/ChartGPU/examples/million-points/

Currently supports line, area, bar, scatter, pie, and candlestick charts. MIT licensed, available on npm: `npm install chartgpu`

Happy to answer questions about WebGPU internals or architecture decisions.

The article discusses an incident where the 'Anna's Archive' website was suspended, which was initially attributed to a Spotify data scrape. However, the article states that the suspension was actually due to a different issue unrelated to the Spotify data scrape, and the website has since been restored.

https://www.anthropic.com/constitution

The article explores the performance advantages of StarRocks, a distributed SQL database, focusing on its efficient join operations. It highlights how StarRocks' unique architectural design and query optimization techniques enable significantly faster join processing compared to traditional database systems.

The article discusses a vulnerability in the OpenAI API that allows for unpatched data exfiltration, potentially exposing sensitive user data. It highlights the importance of security measures and responsible disclosure in AI systems.

RailsUI is a comprehensive open-source library of UI components and design tools for building modern, responsive web applications with Ruby on Rails. It provides a range of pre-built, visually appealing components that can be easily integrated into Rails projects to accelerate development and enhance the user experience.

Skip, a new app, has announced that it will be completely free to use. The article discusses the company's decision to make Skip free, highlighting their focus on providing accessible financial services.

Jerry, Inc. is seeking a Software Engineer to join their core automation marketplace team. The role involves building and scaling infrastructure and tools to power Jerry's automated insurance services.

The article discusses the importance of LLM (Large Language Model) workloads, highlighting their growing significance in the field of artificial intelligence and their potential applications across various industries.

https://www.blueorigin.com/terawave

https://arstechnica.com/space/2026/01/blue-origin-we-want-to...

The article explores the capabilities of the AI model Claude in playing text adventure games. It examines Claude's performance in navigating and solving these interactive fiction games, highlighting its strengths and limitations in comprehending and responding to the textual environments.

eBay has banned the use of AI agents and updated its user agreement, requiring arbitration of disputes starting in February 2026. The changes aim to address concerns around the use of AI tools and ensure a fair dispute resolution process for eBay users.

The article discusses the potential of a new search engine, Kagi, which aims to provide a more personalized and privacy-focused search experience compared to major search engines. It highlights Kagi's focus on user control, data privacy, and delivering high-quality search results through a curated approach.

The article explores the implications of artificial intelligence (AI) being both highly capable and widely deployed, raising concerns about the potential for unintended consequences and the need for careful governance and oversight of this powerful technology.

AdGuard VPN has announced the open-sourcing of its VPN protocol, TrustTunnel, providing transparency and enabling the community to audit and contribute to the protocol's development. This move aims to enhance trust and security in AdGuard VPN's offerings.

The article explores the concept of parallel computing, which involves dividing a complex task into smaller parts that can be processed simultaneously. It discusses the advantages of parallel computing, such as improved performance and efficiency, and the various types of parallel architectures and programming models used in modern computing.

The article explores the life and work of renowned American author Joan Didion, highlighting her enduring influence on literary and cultural discourse through her incisive observations and distinctive writing style. It provides insights into Didion's personal experiences and the themes that have defined her acclaimed body of work.

Hey HN! I'm Fabio and I built UltraContext, a simple context API for AI agents with automatic versioning.

After two years building AI agents in production, I experienced firsthand how frustrating it is to manage context at scale. Storing messages, iterating system prompts, debugging behavior and multi-agent patterns—all while keeping track of everything without breaking anything. It was driving me insane.

So I built UltraContext. The mental model is git for context:

- Updates and deletes automatically create versions (history is never lost)

- Replay state at any point

The API is 5 methods:

  uc.create()   // new context (can fork from existing)
  uc.append()   // add message
  uc.get()      // retrieve by version, timestamp, or index
  uc.update()   // edit message → creates version
  uc.delete()   // remove message → creates version

What it's for:

- Persisting conversation state across sessions

- Debugging agent behavior (rewind to decision point)

- Forking contexts to test different flows

- Audit trails without building audit infrastructure

- Multi-agent and sub-agent patterns

What it's NOT:

- Not a memory/RAG system (no semantic search)

- Not a vector database

- Not an Orchestration/LLM framework

UltraContext handles versioning, branching, history. You get time-travel with one line.

Docs: https://ultracontext.ai/docs

Early access: https://ultracontext.ai

Would love feedback! Especially from anyone who's rolled their own context engineering and can tell me what I'm missing.

Hi,

I started Muky in April 2024. Classic side project that got out of hand. We have two kids - the younger one is happy with the Toniebox, but our older one outgrew it. She started asking for specific songs, audiobooks that aren't available as figurines, and "the music from that movie."

We had an old iPad Mini lying around and already pay for Apple Music. Felt dumb to keep buying €17/$20 figurines for 30-45 minutes of content when we have 100 million songs.

Now at version 4.0 after ~20 updates. Some lessons:

On the hardware vs app tradeoff: Toniebox and Yoto are brilliant for little ones – tactile, simple, no screen needed. But they hit a wall once kids want more. And handing a 5-year-old Apple Music means infinite scrolling and "Dad, what's this song about?" Muky sits in between – full library access, but parents control what's visible.

On sharing: Remember lending CDs or cassettes to friends? Or kids swapping Tonie figurines at a playdate? I wanted that for a digital app. So I built QR code sharing. Scan, import, done. And unlike a physical thing – both keep a copy.

On onboarding: First versions: empty app, figure it out yourself. Retention was awful. Now: 4-step onboarding that actually guides you. Should've done this from the start.

On content discovery: 100 million songs sounds great until you have to find something. Parents don't want to search – they want suggestions. Spent a lot of time building a Browse tab with curated albums and audiobooks for kids. Finally feels like the app helps you instead of just waiting for input.

On going native: Went with Swift/SwiftUI instead of Flutter or React Native. No regrets - SwiftUI is a joy to work with and performance is great. Android users ask for a port regularly. No capacity for that now, but Swift for Android is progressing (https://www.swift.org/documentation/articles/swift-sdk-for-a...). Maybe one day. CarPlay is another one parents keep asking for – going native should make that easier to add, if Apple grants me the entitlement.

On subscriptions vs one-time: Started with one-time purchase. Revenue spikes at launch, then nothing. Switched to subscription – existing one-time buyers kept full access. Harder to sell, but sustainable.

Ask me anything about indie iOS dev or building for kids. App is at https://muky.app if you're curious.

The article introduces SIMD (Single Instruction, Multiple Data) in Rust, a powerful technique for improving performance by processing multiple data elements simultaneously. It covers the basics of SIMD, including its benefits, how to use it in Rust, and provides examples of SIMD in action.

I built a simple tool to compare hard drive and SSD prices by price-per-terabyte.

I kept having to calculate $/TB manually when shopping for NAS drives, so I made this to save myself the trouble.

It pulls prices from Amazon (US, CA, AU, and EU stores), calculates $/TB, and lets you filter by drive type, interface, form factor, and capacity.

Nothing fancy — just a sortable table updated daily.

Any feedback is more than welcome, I hope someone will find it useful!

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!

A common approach to automating Amazon shopping or similar complex websites is to reach for large cloud models (often vision-capable). I wanted to test a contradiction: can a ~3B parameter local LLM model complete the flow using only structural page data (DOM) plus deterministic assertions?

This post summarizes four runs of the same task (search → first product → add to cart → checkout on Amazon). The key comparison is Demo 0 (cloud baseline) vs Demo 3 (local autonomy); Demos 1–2 are intermediate controls.

More technical detail (architecture, code excerpts, additional log snippets):

https://www.sentienceapi.com/blog/verification-layer-amazon-case-study

Demo 0 vs Demo 3:

Demo 0 (cloud, GLM‑4.6 + structured snapshots) success: 1/1 run tokens: 19,956 (~43% reduction vs ~35k estimate) time: ~60,000ms cost: cloud API (varies) vision: not required

Demo 3 (local, DeepSeek R1 planner + Qwen ~3B executor) success: 7/7 steps (re-run) tokens: 11,114 time: 405,740ms cost: $0.00 incremental (local inference) vision: not required

Latency note: the local stack is slower end-to-end here largely because inference runs on local hardware (Mac Studio with M4); the cloud baseline benefits from hosted inference, but has per-token API cost.

Architecture

This worked because we changed the control plane and added a verification loop.

1) Constrain what the model sees (DOM pruning). We don’t feed the entire DOM or screenshots. We collect raw elements, then run a WASM pass to produce a compact “semantic snapshot” (roles/text/geometry) and prune the rest (often on the order of ~95% of nodes).

2) Split reasoning from acting (planner vs executor).

Planner (reasoning): DeepSeek R1 (local) generates step intent + what must be true afterward. Executor (action): Qwen ~3B (local) selects concrete DOM actions like CLICK(id) / TYPE(text). 3) Gate every step with Jest‑style verification. After each action, we assert state changes (URL changed, element exists/doesn’t exist, modal/drawer appeared). If a required assertion fails, the step fails with artifacts and bounded retries.

Minimal shape:

ok = await runtime.check( exists("role=textbox"), label="search_box_visible", required=True, ).eventually(timeout_s=10.0, poll_s=0.25, max_snapshot_attempts=3)

What changed between “agents that look smart” and agents that work Two examples from the logs:

Deterministic override to enforce “first result” intent: “Executor decision … [override] first_product_link -> CLICK(1022)”

Drawer handling that verifies and forces the correct branch: “result: PASS | add_to_cart_verified_after_drawer”

The important point is that these are not post‑hoc analytics. They are inline gates: the system either proves it made progress or it stops and recovers.

Takeaway If you’re trying to make browser agents reliable, the highest‑leverage move isn’t a bigger model. It’s constraining the state space and making success/failure explicit with per-step assertions.

Reliability in agents comes from verification (assertions on structured snapshots), not just scaling model size.

The article discusses the use of nested code fences in Markdown, a feature that allows embedding code blocks within other code blocks. It explains the purpose and syntax of this feature, highlighting its usefulness in creating more complex and structured code samples.

This article explores ways to slim down macOS, such as removing unused apps, disabling visual effects, and managing storage, to improve performance and free up disk space on older or less powerful Mac devices.

The article discusses the development of JPEG XL, a new image format designed to replace JPEG. JPEG XL aims to provide better compression, support for HDR and transparency, and improved visual quality compared to JPEG, while maintaining compatibility with existing systems.