Show HN: Fast Elevation API with memory mapped tiles https://ift.tt/wpxiYuW

Show HN: Fast Elevation API with memory mapped tiles I recently wrote and launched a high-performance Elevation API, built from the ground up, in C. I was highly inspired by the handmade community and I was intrigued by the idea of handling fairly large datasets and optimizing caching and smart prefetching, and to cream out maximum performance in terms of latency and handling large loads. The whole thing is built from scratch. I wanted to roll my own high performance server that could handle a lot, mostly for the technical challenge but also because it brings down hosting costs. At the core is a hand made TCP server where a single thread handles all I/O via epoll, distributing the events to a pool of worker threads. The server is fully non-blocking and edge-triggered, with a minimal syscall footprint during steady-state operation. Worker threads handle request parsing and perform either direct elevation lookups for single- or multi-points, or compute sample points along polyline paths. The elevation data is stored as memory mapped geotiff raster tiles, The tiles are indexed in an R-tree for fast lookup. Given a coordinate, the correct tile is located with a bounding-box search algorithm through the tree, and the elevation value is extracted directly from the mapped memory. If the tile is missing the data, underlying tiles act as fallback. I also implemented a prefetching mechanism. That is, to avoid repeated page faults in popular areas, I employ a strategy where each tile is divided into smaller sub-tiles. Then, I have a running popularity count per sub-tile. This information is then used to guide prefetching. More popular sub-tiles trigger larger-radius prefetches around the lookup point, with the logic that if a specific region is seeing frequent access, it’s worth pulling in more of it into RAM. Over time, this makes the memory layout adapt to real usage patterns, keeping hot areas resident and minimizing I/O latency. Prefetching is done using linux madvise, in a separate prefetch thread to not affect request latency. There’s a free option to try it out! https://ift.tt/HtVm9T1 August 3, 2025 at 02:42AM

Show HN: Open-sourced my prompt management tool for LLM-powered apps https://ift.tt/1kGQol0

Show HN: Open-sourced my prompt management tool for LLM-powered apps https://ift.tt/J0yNXzx August 3, 2025 at 01:42AM

Show HN: F1 COSMOS – Live timing and data dashboard for F1 fans https://ift.tt/GMrn6Zz

Show HN: F1 COSMOS – Live timing and data dashboard for F1 fans Hey everyone! I'm a huge F1 fan and got tired of juggling multiple tabs and apps during race weekends, so I built F1 COSMOS. What it does: - Live timing: Real-time data updates in milliseconds - sector times, telemetry, team radio, you name it. No more refreshing pages or waiting for delayed updates. - Replay feature: Missed qualifying or fell asleep during practice? You can replay the live timing from any past session. Pretty handy when you're in a bad timezone. - Proper data visualization: I went beyond just showing lap times. There's race analysis with telemetry data, championship standings, technical updates, and a bunch of other stats that make watching races way more interesting. Oh, and the race calendar automatically adjusts to your timezone because I was sick of doing timezone math in my head. - Multi-device setup: Here's the thing - I watch races on my TV but wanted data on my phone as a second screen. So I spent ages making the mobile experience smooth for exactly this use case. Desktop has customizable widgets if you're into that. Technical stuff: Built with modern web stack, focused heavily on real-time performance. The trickiest part was getting the data pipeline right for millisecond updates without everything falling apart. Why I built this: Honestly, existing F1 apps either suck or cost money or both. I wanted something that just works and gives me all the data I actually care about in one place. Been using it myself all season and figured others might find it useful. Currently supports English, Spanish, Japanese, and Korean (partially) - still working on expanding language support. Would love to hear what you think if you check it out during the next race weekend. https://f1cosmos.com/ August 2, 2025 at 09:58PM

Show HN: WebGPU enables local LLM in the browser – demo site with AI chat https://ift.tt/q1RoMfu

Show HN: WebGPU enables local LLM in the browser – demo site with AI chat Browser LLM demo working on JavaScript and WebGPU. WebGPU is already supported in Chrome, Safari, Firefox, iOS (v26) and Android. Demo, similar to ChatGPT https://andreinwald.github.io/browser-llm/ Code https://ift.tt/ow06cYE - No need to use your OPENAI_API_KEY - its local model that runs on your device - No network requests to any API - No need to install any program - No need to download files on your device (model is cached in browser) - Site will ask before downloading large files (llm model) to browser cache - Hosted on Github Pages from this repo - secure, because you see what you are running https://andreinwald.github.io/browser-llm/ August 2, 2025 at 07:39PM

Shorter, Smoother Rides on Muni Metro: How a Milestone Grant Will Help Us Improve Your Trips

Shorter, Smoother Rides on Muni Metro: How a Milestone Grant Will Help Us Improve Your Trips
By Mariana Maguire

Learn how new funding for our Train Control Upgrade Project will help make your Muni Metro trips more reliable and faster overall. We are working hard to improve your trips on Muni Metro, and a milestone grant will help us make even more progress. We recently won a $41 million state grant from the California Transportation Commission. Its highly competitive Solutions for Congested Corridors Program funds capital infrastructure projects. This grant will provide a vital source of support for our Train Control Upgrade Project (TCUP). The project will overhaul and expand Muni Metro’s outdated...

Published August 01, 2025 at 05:30AM
https://ift.tt/yu8xRHp

Show HN: Tambo – a tool for building generative UI React apps with tools/MCP https://ift.tt/PD1U4Xy

Show HN: Tambo – a tool for building generative UI React apps with tools/MCP Hey! We're working on a React SDK + API to make it simple to build apps with natural language interfaces, where AI can interact with the components on screen on behalf of the user. The basic setup is: Register your react components, tools, and MCP servers, and a way for users to send messages to Tambo, and let Tambo respond with text or components, calling tools when needed. Use it to build chat apps, copilots, or completely custom AI UX. The goal is to provide simple interfaces for common AI app features so we don't have to build them from scratch. Things like: - thread storage/management - streaming props into generated components - MCP and custom tool integration - passing component state to AI plus some pre-built UI components to get started. Would love feedback or contributions! https://ift.tt/TBeLK3s August 2, 2025 at 12:11AM

Show HN: TraceRoot – Open-source agentic debugging for distributed services https://ift.tt/agDiNmB

Show HN: TraceRoot – Open-source agentic debugging for distributed services Hey Xinwei and Zecheng here, we are the authors of TraceRoot ( https://ift.tt/LEpFMcW ). TraceRoot ( https://traceroot.ai ) is an open-source debugging platform that helps engineers fix production issues faster by combining structured traces, logs, source code contexts and discussions in Github PRs, issues and Slack channels, etc. with AI Agents. At the heart are our lightweight Python ( https://ift.tt/q93d1Si ) and TypeScript ( https://ift.tt/8wAyQqL ) SDKs - they can hook into your app using OpenTelemetry and captures logs and traces. These are either sent to a local Jaeger ( https://ift.tt/s8nmbOE ) + SQLite backend or to our cloud backend, where we correlate them into a single view. From there, our custom agent takes over. The agent builds a heterogeneous execution tree that merges spans, logs, and GitHub context into one internal structure. This allows it to model the control and data flow of a request across services. It then uses LLMs to reason over this tree - pruning irrelevant branches, surfacing anomalous spans, and identifying likely root causes. You can ask questions like “what caused this timeout?” or “summarize the errors in these 3 spans”, and it can trace the failure back to a specific commit, summarize the chain of events, or even propose a fix via a draft PR. We also built a debugging UI that ties everything together - you explore traces visually, pick spans of interest, and get AI-assisted insights with full context: logs, timings, metadata, and surrounding code. Unlike most tools, TraceRoot stores long-term debugging history and builds structured context for each company - something we haven’t seen many others do in this space. What’s live today: - Python and TypeScript SDKs for structured logs and traces. - AI summaries, GitHub issue generation, and PR creation. - Debugging UI that ties everything together TraceRoot is MIT licensed and easy to self-host (via Docker). We support both local mode (Jaeger + SQLite) and cloud mode. Inspired by OSS projects like PostHog and Supabase - core is free, enterprise features like agent mode multi-tenant and slack integration are paid. If you find it interesting, you can see a demo video here: https://www.youtube.com/watch?v=nb-D3LM0sJM We’d love you to try TraceRoot ( https://traceroot.ai ) and share any feedback. If you're interested, our code is available here: https://ift.tt/LEpFMcW . If we don’t have something, let us know and we’d be happy to build it for you. We look forward to your comments! https://ift.tt/LEpFMcW August 1, 2025 at 10:28PM