Show stories

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

This article introduces TurboQuant, a high-performance WebAssembly-based quantitative trading framework that enables rapid development and deployment of algorithmic trading strategies. The framework leverages the speed and efficiency of WebAssembly to provide a scalable and cross-platform solution for quantitative finance applications.

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.

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.

Curious what breaks first when people try running cross-environment agent workflows in practice.

Project: https://hybro.ai Docs: https://docs.hybro.ai

"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 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!

Pluck is a new social audio platform that allows users to create and share short audio clips, engage with others through reactions and comments, and discover content based on their interests.

With social media and now AI, its important to keep the indie web alive. There are many people who write frequently. Blogosphere tries to highlight them by fetching the recent posts from personal blogs across many categories.

There are two versions: Minimal (HN-inspired, fast, static): https://text.blogosphere.app/ Non-minimal: https://blogosphere.app/

If you don't find your blog (or your favorite ones), please add them. I will review and approve it.

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

Github: https://github.com/Arthur-Ficial/apfel

“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 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!

Semsei is an AI-powered platform that helps organizations streamline their sales and marketing processes, providing tools for lead generation, customer relationship management, and sales automation.

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)  

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.

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

The article discusses the development and features of the Ctx programming language, which is designed to be a simple and efficient language for building high-performance, concurrent applications. It highlights Ctx's focus on ease of use, concurrency, and high-level abstractions.

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!

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...

Built this to track the ongoing debate around Model Context Protocol - whether it's gaining real traction or just hype. Pulls live data from GitHub, HN, Reddit and a few other sources. Curious what the HN crowd thinks given how active the MCP discussion has been here.

Hey everyone. I built an MTProto proxy for Telegram aimed at bypassing active DPI censorship like the Russian TSPU. I chose Zig because it's perfect for writing fast network daemons and makes it incredibly easy to port low-level C bypass techniques like TCP desync and packet fragmentation. Would love to get some feedback or contributors!

The article discusses Tusk, a new decentralized messaging app that aims to provide secure and private communication without relying on centralized servers or platforms. It highlights Tusk's focus on user privacy, encryption, and decentralized architecture.

Made a little Artemis II tracker for anyone else who is unnecessarily invested in this mission:

https://artemis-ii-tracker.com/

For those of us who apparently need a dedicated place to monitor this mission instead of behaving like well-adjusted people.

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 kept deleting and redownloading Instagram because I couldn't stop watching Reels but needed the app for DMs. Tried screen time limits, just overrode them. So I built this.

Dull loads Instagram, YouTube, Facebook, and X and filters out short-form content with a mix of CSS and JS injection. MutationObserver handles anything that lazy-loads after the page renders, which is most of the annoying stuff since these platforms love to load content dynamically.

The ongoing work is maintaining the filters. Platforms change their DOM all the time, Instagram obfuscates class names, YouTube restructures how Shorts appear in the feed, etc. It's a cat-and-mouse thing that never really ends.

Also has grayscale mode, time limits, and usage tracking.

Happy to answer questions.

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!

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.

The article discusses TinyOS, a free and open-source operating system designed for wireless sensor networks. It highlights TinyOS as a lightweight, event-driven, and component-based system that provides a framework for developing energy-efficient embedded systems.