2026年4月4日 的 Show HN

Thought the resources for GPU arch were lacking, so here we are

Running DeepSeek V3 (685B) requires 8×H100 GPUs which is about $14k/month. Most developers only need 15-25 tok/s. sllm lets you join a cohort of developers sharing a dedicated node. You reserve a spot with your card, and nobody is charged until the cohort fills. Prices start at $5/mo for smaller models.

The LLMs are completely private (we don't log any traffic).

The API is OpenAI-compatible (we run vLLM), so you just swap the base URL. Currently offering a few models.

The latest 3Blue1Brown video [1] about the M. C. Escher print gallery effect inspired me to re-implement the effect as WebGL fragment shader on my own.

[1]: https://www.youtube.com/watch?v=ldxFjLJ3rVY

I love getting cool swag from hackathons and I also love designing PCB's, so when my friend asked me if I would design hackathon badges for a large game jam in singapore, I was absolutely down!

The theme of overglade was a "The game jam within a game", pretty cool concept right! High schoolers from around the world were flown out to the event by hackclub after they spent about 70 hours designing their own game.

These badges needed to be really cheap and simple, because we were going to manufacture about a hundred in a pretty limited amount of time. I went with a zero-power approach, which means sticking with e-inks, and I decided to include NFC if the organizers wanted to introduce it into the roleplay of the event, and so participants could add their website or github if they so choose!

I used an RP2040-based architecture because it's really easy and cheap to get on the first try, and then added an ST25 passive NFC tag which was really simple to configure. The badge is in the shape of a ticket, because you got a "ticket" to the event after spending a lot of time designing games to qualify! 20 GPIO's are broken out onto the edges if you're ever in a pinch at a hackathon, and I wanted the badges to feel really fun so there's a lot of art designed by various people in the community!

The badge worked really well and I learned quite a lot in the process. My takeaways are to manufacture a BUNCH of extra badges, because some will end up breaking; to think about your PCB in 3D, because one of the inductors was a bit tall and caused more badges to break; and to have a strong vision of your final product, because it really helped me to create something unique and beautiful :D

I like to journal about all my projects, so if you'd like to read my full design process, feel free to take a look at my journal (https://github.com/KaiPereira/Overglade-Badges/blob/master/J...). If you also have any questions or feedback, I'd be happy to answer them!

I pretty much always have a kernel project going on, and have been that way for decades. Over the past couple of years, that's been Anos, which has gotten further along than any of my previous hobby kernels, supporting IPC, multitasking, SMP (x86-64 only right now) and running on real hardware.

LLMs (mostly Claude Code) have been used during development, but I learned early on that it's not _great_ at code at this level, so I've restricted its use to mostly documentation and tests. There's _a little_ AI code in the user space, but I have a strict "no AI code" rule in the kernel itself. I find this helps not only with the quality / functionality of the code, but also with learning - for example, even though I've written multiple kernels in the past, it wasn't until Anos that I _truly_ grokked pagetable management and what was possible with a good VMM interface, and if I'd outsourced that implementation to an LLM I probably wouldn't have learned any of that.

In terms of approach, Anos avoids legacy platform features and outdated wiki / tutorial resources, and instead tries to implement as much as possible from manuals and datasheets, and it's definitely worked out well so far. There's no support for legacy platform features or peripherals, with all IO being memory mapped and MSI/MSI-X interrupts (no PIC), for example, which has helped keep the codebase focused and easy to work on. The kernel compiles to about 100KiB on x86-64, with enough features to be able to support multitasking and device drivers in user space.

As a hobby project, progress ebbs and flows with pressures of my day job etc, and the main branch has been quiet for the last few months. I have however been working on a USB stack as time allows, and hopefully will soon have at least basic HID support to allow me to take the next step and make Anos interactive.

I don't know how useful projects like Anos are any more, given we now live in the age of AI coding, but it's a fun learning experience and helps keep me technically grounded, and I'll carry on with it for as long as those things remain true.

I use points and miles for most of my travel. Every booking comes down to the same decision: use points or pay cash? To answer that, you need award availability across multiple programs, cash prices, your current balances, transfer partner ratios, and the math to compare them. I got tired of doing it manually across a dozen tabs.

This toolkit teaches Claude Code and OpenCode how to do it. 7 skills (markdown files with API docs and curl examples) and 6 MCP servers (real-time tools the AI calls directly).

It searches award flights across 25+ mileage programs (Seats.aero), compares cash prices (Google Flights, Skiplagged, Kiwi.com, Duffel), pulls your loyalty balances (AwardWallet), searches hotels (Trivago, LiteAPI, Airbnb, Booking.com), finds ferry routes across 33 countries, and looks up weird hidden gems near your destination (Atlas Obscura).

Reference data is included: transfer partner ratios for Chase UR, Amex MR, Bilt, Capital One, and Citi TY. Point valuations sourced from TPG, Upgraded Points, OMAAT, and View From The Wing. Alliance membership, sweet spot redemptions, booking windows, hotel chain brand lookups.

5 of the 6 MCP servers need zero API keys. Clone, run setup.sh, start searching.

Skills are, as usual, plain markdown. They work in OpenCode and Claude Code automatically (I added a tiny setup script), and they'll work in anything else that supports skills.

PRs welcome! Help me expand the toolkit! :)

https://github.com/borski/travel-hacking-toolkit

I've spent the last years obsessed with a sideproject to build a humanistic 3D modeler for desktop.

By humanistic I mean a tool that stays out of your way, instead of requiring the user to learn both a complex UX surface as well as a complex theoretical basis before being able to model effectively. The GUI is uncrowded and the modeling affordances are only those which are intuitive to present to the user. Which is sort of backwards compared to most CAD packages where the technical complexity takes the front stage. Here the hierarchy is intentionally reversed.

This is still in alpha-stage, but the features are mature enough for feedback and experimentation.

TinkerCAD is actually what comes philosophically closest to this, but it's hobbled either by Autodesk's strategy or by technical limitation to be a really good tool beyond certain complexity.

The ambition here eventually is to provide a tool that has same intuitive capability as building Lego bricks, while not compromising on engineering qualities.

The main intent is to make extrusion based modeling operations super easy, to offer robust STL and STEP import and allow complex modeling via boolean operations.

The modeling logic is parametric and volume based - the surface presentation is always a discretized water tight triangle mesh.

This is the clearest philosophical differentiator to traditional CAD/CAM packages - or visual editors like Blender. Rather than force the user to nurse surface topology at every stage, the modeler will only permit those operations that result in a correct output.

This is not an SDF (signed distance field) modeler. The domain model is fully based on parametric analytic shapes. This means the tessellation is crisp and specific.

The modeling data is immutable and serialized to disk while modeling. For the user this gives a perfect undo and zero data loss.

It's built for efficiency first - my test workhorse is a Thinkpad T14 Gen 2 i5 with an integrated gpu.

It's not supposed to be a replacement for complex surface design tools like Fusion 360 or sculpting software like Nomad Sculpt or Z Brush.

You can find a review of current features in the youtube playlist linked below [0] and the link to the latest alpha 0.1.7 download from the homepage [1]. The test binary is provided via github release [2] but this is not an open source project.

I know some people hate videos over reading and I'm one of you but I don't really have bandwidth to both develop features and write good instruction copy.

[0] https://www.youtube.com/playlist?list=PLCOf_M8a2MZJqgKXgjod2...

[1] https://adashape.com

[2] https://github.com/AdaShape/adashape-open-testing/releases/t...

Hi HN,

I’ve been having a lot of fun building Docking, an open-source dock for Linux written in Python with GTK 3 and Cairo. It includes an extensible applet system, 38 built-in applets, 12 themes, multi-monitor support, auto-hide, and works across several Linux/X11 desktop environments.

It also has prebuilt releases for x64 and arm64 across multiple package formats: AppImage, .deb, RPM, Flatpak, Snap, Arch, and Nix outputs.

GitHub: https://github.com/edumucelli/docking

Feedback is very welcome!

ownscribe is an open-source, python-based CLI tool to transcribe, summarize, and search meetings – fully locally on your machine.

As someone who hates taking notes, but also forgets things easily, I found the idea of transcribing and summarizing meetings automatically neat. However, all the existing tools out there store everything on their servers, don't work with every type of meeting, and cost $30/month or more.

I wanted a tool that just runs locally and uses a very simple format (like .md) to integrate with my other workflows – but there wasn't anything like that. That's why I started to build ownscribe over the past few months and continuously improved it. It started as just a tool for transcription and summarization, and now even allows you to search past meetings with natural language (and a local LLM).

At the moment, it is mainly optimised for macOS (although Linux should also partially work). I'd love to have some more feedback on how to make it more useful!

Was curious how a personality test would look for developers. So created this using FastAPI, HTMX, and AlpineJS.

I think everyone has already read Karpathy's Post about LLM Knowledge Bases. Actually for recent weeks I am already working on agent-native knowledge base for complex research (DocMason). And it is purely running in Codex/Claude Code. I call this paradigm is: The repo is the app. Codex is the runtime.

During my daily working life, I have tons of office documents with knowledge from all teams, and as an IT Architect, I need to combine them altogether to handle complex deep research (which normal LLM definitely could not help). That is the originally reason I built DocMason, and I am using it in everyday which support me on lots of complex topics.

I have already open-sourced this repo. And I think it takes Karpathy's concept a step further for real-world usage in three ways: 1. It could handle most kinds of office docs (pptx, docx, excels, even .eml). And really extract multimodal information from all IT architecture diagram or excel sheets. 2. It is running as a Real APP but not a naive RAG tool. DocMason could run smoothly and intelligently to prepare environment, auto update, and auto incrementally sync Knowledge base. 3. Most importantly it is running in Native AI Agents, which could leverage powerful AI Agents engine (e.g. Codex or Claude Code)

View detail architecture diagram in DocMason Readme, and then download have a try :) You will find it could help a lot during daily work. Would love to hear your feedback and issues in Github!

There are plenty of Artemis II trackers out there. I looked at a bunch and kept running into the same issues - some had data that didn't look right, it was hard to use on smaller screen, others felt overly complicated for what I actually wanted to know: what's the crew doing, where is Orion, how fast is it going. The best one I found was issinfo.net/artemis, which inspired a lot of the design.

So I built my own. The part that was genuinely interesting to me was the data. Turns out anyone can query JPL's Horizons API for full ephemeris data on the Orion spacecraft - position, velocity, range - for free. I had no idea this existed.

Even better: NASA's Deep Space Network publishes a live XML feed (eyes.nasa.gov/dsn/data/dsn.xml) that updates every 5 seconds showing exactly which ground antennas are talking to which spacecraft. Right now two dishes in Canberra are locked onto Orion - one sending commands, both receiving 6 Mbps of S-band telemetry at 296,000 km. You can see Juno at Jupiter, JWST, Mars Odyssey, all in the same feed. It's pretty amazing what's just sitting there in the open.

The app fetches trajectory from Horizons, crew activities from NASA's published flight plan, and live ground station status from DSN. I'll be honest - it's mostly vibe-coded with supervision. The data pipeline is the part that was more manual: figuring out what's publicly available, how to compute relative positions from raw vectors, how to cache and backfill. That was the fun part.

Code is open on GitHub. I built it for myself and as a fun exercise, but happy for any feedback - especially around data correctness and what other public data sources are out there that I might be missing.

Source: https://github.com/dmarchuk/artemis.fyi

Netflix compresses 4K to 15 Mbps. A Blu-ray remux is 60 Mbps. Dark scenes, fast motion, grain. That's where you see it.

I wanted my family to have Blu-ray quality with a streaming UX. They open Overseerr on their phone, request a movie, and it shows up in Infuse on Apple TV. Subtitles in three languages, hardware transcoding for mobile, full remux on the big screen. They have no idea what's behind it.

What's behind it: Sonarr, Radarr, Prowlarr find and grab content. qBittorrent downloads through a WireGuard tunnel. Bazarr pulls subtitles. Jellyfin serves it all. Everything self-heals — endpoint health checks, autoheal restarts, dependency ordering so nothing starts in a broken state.

The security model is the part I obsessed over:

- qBittorrent shares Gluetun's network namespace at the kernel level. No firewall rule to misconfigure — if the VPN drops, there's no network path. - Traefik binds to a Tailscale IP only. Zero ports face the internet. - Three isolated Docker networks separate ingress, internal, and P2P traffic.

Two Compose stacks, one .env file, MIT licensed.

https://github.com/Lackoftactics/uncompressed

I built @pretext-studio/core to solve a specific annoyance: the browser won't tell you how tall a text block is until after it renders. This forces you into either a render-then-measure cycle (which causes layout shift) or hacks like max-height: 9999px for accordion animations (which makes easing look wrong because the animation runs over 9999px, not the actual content height).

The library wraps @chenglou/pretext, a pure-JS text layout engine that replicates the browser's line-breaking. algorithm using font metrics loaded once via the Font Metrics API. From there, computing height is arithmetic — no DOM, no getBoundingClientRect, no reflow. A prepare() call runs in ~0.03ms; a layout() call in under 0.01ms. Results are cached in a module-level LRU map so repeated calls for the same font/size pair are nearly free.

The main hooks are useTextLayout (height + line count for a block at a given width), useBubbleMetrics (finds the tightest width that preserves line count, which eliminates the dead space you get from CSS fit-content), and useStableList (pre-computes heights for a list of items before paint, useful for virtualized lists and masonry layouts). There's also a MeasuredText drop-in component with a debug overlay that draws predicted line boundaries over actual rendered text so you can see where predictions diverge.

The honest limitation: it only works with fonts you can load metrics for, so arbitrary system fonts or poorly-behaved variable fonts may drift. The isReady flag on every hook is false until font metrics load, so you need to gate renders on it when using web fonts. It also doesn't handle white-space: pre-wrap yet. Feedback welcome — especially if you've hit edge cases with font loading or non-Latin scripts.

GitHub: https://github.com/ahmadparizaad/pretext-studio-core — npm: @pretext-studio/core

Read an article yesterday about the H.264 codec increasing their licensing fee by an astronomical amount.

And as always, my first shot was how hard could it be to try and build a codec which could be that efficient.

I've personally been on a drive to improve my ability to one-shot complex features, products, or make even surgical changes. It's been a few months since I've been doing that, and honestly, results have been great for both work and work/life balance.

This was a fun experiment. It burned through tokens, but it helped me identify some more improvements I could make to my one-shot agent teams/swarms, notably in the area of brevity and creating a testing rubric when dealing with domains I don't have prior knowledge in.

Ultimately, I did not achieve the compression that I hoped I would, but it was fun seeing the swarm discuss it amongst themselves.

I built this after hitting the same wall repeatedly — no good way to enforce token budgets in application code. Provider caps are account-level and tell you what happened, not what is happening.

Two ways to add it:

  # Direct client wrapper
  client = tokencap.wrap(anthropic.Anthropic(), limit=50_000)

  # LangChain, CrewAI, AutoGen, etc.
  tokencap.patch(limit=50_000)  

Four actions at configurable thresholds: WARN, DEGRADE (transparent model swap), BLOCK, and WEBHOOK. SQLite out of the box, Redis for multi-agent setups.

One design decision worth mentioning: tokencap tracks tokens, not dollars. Token counts come directly from the provider response and never drift with pricing changes.

Happy to answer any questions.

Analyse and Trade directly from Telegram. Openclaw integration.

Hi HN — I’m building an interoperability layer for AI agents that lets local and remote agents run inside the same network and coordinate with each other.

Here is a demo: https://youtu.be/2_1U-Jr8wf4

• OpenClaw runs locally on-device • it connects to remote agents through Hybro Hub • both participate in the same workflow execution

The goal is to make agent-to-agent coordination work across environments (local machines, cloud agents, MCP servers, etc).

Right now most agent systems operate inside isolated runtimes. Hybro is an attempt to make them composable across boundaries.

Web portal: https://hybro.ai Docs: https://docs.hybro.ai

“I built a simple app to give yourself some time. Alnuo. You choose when. You choose how long. It reminds you. No account. That’s it. Feedback welcome. ”

I built a little tool that lets you subscribe to posts, comments and users and get notified when they change.

It needs an account on val.town, but that's about it.

Also note, for top stories it can get quite chaotic.

A small tool that uses HTTP range requests to explore ZIP archives remotely — list contents and download specific files without fetching the entire archive.

Try out this URL (https://docs.python.org/3/archives/python-3.14-docs-text.zip) as an example.

"I've been building a sandbox on a Linux VPS to push AI video generation and visualization to the extreme. It's a mix of experimental generative art and high-intensity visuals. Built with Python, running on Debian. Check it out and let me know what you think!"

I had one question: when do birds show up at my bird feeder?

Setup: Raspberry Pi Zero 2W + USB webcam + Supabase (free tier) + 93 lines of Python that captures a 1280x720 frame every 60 seconds with retry logic for the Pi's flaky WiFi.

Analysis: Ran 1,500 images through Qwen 2.5 VL 7B via OpenRouter API. 996 tokens per image. Total cost: $0.37.

Results:

- 433 birds detected across 3 days (23.7% of frames) - Peak hour: 3 PM (86 birds), not dawn like I expected - Afternoon (12-5 PM) accounts for 70% of all activity - Day 3 had 6x more birds than Day 1 — Bird NPS of 100, they told the flock - Biggest frame: 5 sparrows simultaneously - Species mix: house sparrows, house finches, pigeons, one possible hawk

Hardware BOM: $80.23. Running for a year would cost ~$27 in API.

Page has the interactive dashboard, real captured images, and links to the code.

Hi HN!

We built Clusterflock to solve our own headaches with managing AI agents across distributed setups, different VRAM and RAM allowances, and the need to easily try out new models.

While we focus on infrastructure (we built this specifically for networked hardware) it does ship with a powerful mission runner (or orchestrator), which is multi-session and asynchronous.

Here is what it does best:

Hardware-aware auto-downloading: It profiles your networked hardware and automatically pulls down the best models for your specific setup (currently only from HuggingFace).

Tight packing: Native parallelism via llama.cpp, you can allow it to fit multiple smaller models on same device.

It is fully open-source. We wanted a painless way to deploy agentic clusters, and we hope you find it useful too.

Website: https://clusterflock.net

Happy to hear feedback. Flocks very much given.

Hey everyone, I run a video editing agency for real estate agents (but I’m not a video editor). So I hired video editors to edit the videos for me which works pretty good. However I struggled with the delays in getting edits done, people taking days off and overall workload getting too large.

So I’ve spent the last two months building Alys - Alys is an agentic video editor: There’s no timeline, you literally just chat to make edits to the videos. ChatGPT for video editing basically.

My honest reflection on the tool at this point:

The good: - Good output quality is possible, but it takes the right prompts. It feels a bit like Claude code when it first came out, there’s some signs of brilliance, but it’s very rarely in one shot. To back this up, I recently sold a $1k video package based on a video made by Alys. - The animated overlays work great - In my limited editing work, I’ve always struggled with creating text that looks good and meets the ‘vibe’ of the video. Alys can create animations and text reveals from specific descriptions which look better than any templates I’ve used in other editing software - It saves time - I just added ‘templates’ which basically means at the end of an editing/prompting session when I am happy with the result, I can save this as a template. Then the next time I want to make a similar video, it can use this video result as inspiration.

The bad: - Alys still requires some thought from the user to create good videos (prompting matters). Coming back to the early Claude Code/Cursor days - the prompt you give Alys is important. It’s easy to forget now that Claude Code can one-shot complex features, but 12 months ago you’d have to write an elaborate prompt and then iterate 5-6 times to get code that complied. The same is true with Alys - she can create good videos, but just requires good prompting - Speed: maybe I’m just impatient, but waiting 2 mins for an edit feels too long for me. There’s a real trade off between speed and quality of results which I’m still trying to balance. Claude Code can work for 10 mins on a problem and I don’t mind as it will often be 95% of the way there after the first iteration. Alys needs to get as good.

The future: - I believe the real unlock is to give Aly’s video engine more options for creativity, and truly expand to allow her to have all the features available in a modern video editor. - As well as improving the examples and prompting she receives to truly let show her what video editing looks like across difference styles.

Anyway I’d love for some feedback and for you to try it out. I have a free plan with sensible limits (sadly video rendering on GPU’s is expensive, so there is a paid option).

Thanks!

TV Spot: https://www.youtube.com/watch?v=nCbdxy6JZqY

After watching Claude Code and Codex keep running Explore in my codebase over and over, I started to think that there must be a better way. RemembrallMCP is my attempt to fix this.

RemembrallMCP gives agents two things most memory tools don't:

1. Persistent Memory - Decisions, patterns, and organizational knowledge that survive between sessions. Hybrid semantic + full-text search finds relevant context instantly.

2. Code Dependency Graph - A live map of your codebase built with tree-sitter. Functions, classes, imports, and call relationships across 8 languages. Ask "what breaks if I change this?" and get an answer in milliseconds - before the agent touches anything.

Run the whole thing inside a docker container for getting started easily. Claude uses MCP to leverage it. Written in Rust.

I was diagnosed with cancer last year and found myself drowning in numbers — biomarkers (CEA, LDH), white blood cell counts, hemoglobin, daily pain and fatigue scores, medication logs, bowel movements (colorectal cancer), plus Apple Health data like steps, heart rate, and sleep. No app I tried could handle arbitrary metrics with real analytical tools, so I built one. Meetrics lets you log any numeric, binary (yes/no), or discrete value with a tag, then explore it — rolling averages, 2σ outlier filtering, heatmaps, streak tracking with Bayesian probability estimates, and a Correlate tool that finds relationships between any two tags with adjustable time lag and bucket size.

The Correlate feature is what made it click for me. I found that my chemo side-effects peaked at an 8-day lag — not when the doctors said they would. I showed the chart to my oncologist and it changed the conversation from "I think the side-effects come later than you warned" to "here's the data."

Recently my CT scan showed all tumors shrinking for the first time. Digging into the data, the clearest signal is a sharp increase in daily steps over the past month — partly better weather, partly a new puppy who needed walking. Steps are a known predictor of cancer survival, and the correlation-with-lag tool made it easy to see the timing line up with my scan window.

There's also a premium AI Analyst tab (powered by Claude) that answers natural-language questions about your data and generates daily insight cards. It's how I pay the bills while I'm not working and fighting cancer — the core tracking and analytics are free.

The app is general-purpose. I use it for cancer, but it works for anything — habits, grades, mood, workouts, macro data. I wrote a separate post using it to find the 12-18 month lag between Fed rate changes and unemployment.

Free on iOS: https://apps.apple.com/us/app/meetrics/id6760925743 Full write-up with screenshots: https://github.com/sergeybok/meetrics-support/blob/main/BLOG... Would love feedback from the QS/data crowd here.