Show HN: Simple modenized .NET NuGet server reached RC

Torchcomms: A modern PyTorch communications API

Show HN: A fast, privacy-first image converter that runs in browser

Show HN: A fast, privacy-first image converter that runs in browser Hey HNI built ImageConverter.dev because I got tired of “free” image converter sites that force uploads, or throttle conversions.So I made a tool that runs 100% client-side — meaning your images never leave your device. It’s built for speed, simplicity, and privacy.What it doesConvert images between JPG, PNG, WebPWorks offline once loaded (PWA support)How it worksIt uses the Canvas API and WebAssembly to handle conversions directly in the browser. There’s no upload, no tracking, no server costs, and it’s fast even on mid-range devices.Why I built itI wanted an instant, no-ads, privacy-safe way to handle images for my personal projects — something lightweight enough to replace desktop tools.Try it<a href="https://imageconverter.dev" rel="nofollow">https://imageconverter.dev</a>Would love feedback from the community — especially on:Performance on different browsers/devicesThanks for reading!

Show HN: Git for LLMs – a context management interface

Show HN: Git for LLMs – a context management interface Hi HN, we’re Jamie and Matti, co-founders of Twigg.During our master’s we continually found the same pain points cropping up when using LLMs. The linear nature of typical LLMs interfaces - like ChatGPT and Claude - made it really easy to get lost without any easy way to visualise or navigate your project.Worst of all, none of them are well suited for long term projects. We found ourselves spending days using the same chat, only for it to eventually break. Transferring context from one chat to another is also cumbersome. We decided to build something more intuitive to the ways humans think.We started with two simple ideas. Enabling chat branching for exploring tangents, and an interactive tree diagram to allow for easy visualisation and navigation of your project.Twigg has developed into an interface for context management - like “Git for LLMs”. We believe the input to a model - or the context - is fundamental to its performance. To extract the maximum potential of an LLM, we believe the users need complete control over exactly what context is provided to the model, which you can do using simple features like cut, copy and delete to manipulate your tree.Through Twigg, you can access a variety of LLMs from all the major providers, like ChatGPT, Gemini, Claude, and Grok. Aside from a standard tiered subscription model (free, plus, pro), we also offer a Bring Your Own Key (BYOK) service, where you can plug and play with your own API keys.Our target audience are technical users who use LLMs for large projects on a regular basis. If this sounds like you, please try out Twigg, you can sign up for free at <a href="https://twigg.ai/" rel="nofollow">https://twigg.ai/</a>. We would love to get your feedback!

I built an F5 QKview scanner for CISA ED 26-01

Show HN: Solving the cluster 1 problem with vCluster standalone

Show HN: Solving the cluster 1 problem with vCluster standalone vcluster is an open source tool for Kubernetes multi tenancy and over the years it has matured to have hosted controlplane virtual cluster, shared virtual clusters but the host cluster problem was always there. With vcluster standalone, you can now create the first cluster also with the same developer experience and consolidate the multiple vendor problem. With this, you can now use vcluster for entire multi tenancy spectrum. Feel free to discuss, happy to answer any questuons.

Launch HN: LlamaFarm (YC W22) – Open-source framework for distributed AI

Launch HN: LlamaFarm (YC W22) – Open-source framework for distributed AI Hi HN! We're Rob, Matt, and Rachel from LlamaFarm (<a href="https://llamafarm.dev">https://llamafarm.dev</a>). We're building an open-source AI framework based on a simple belief: the future isn't one massive model in the cloud—it's specialized models running everywhere, continuously fine-tuned from real usage.The problem: We were building AI tools and kept falling into the same trap. AI demos die before production. We built a bunch of AI demos but they were impossible to get to production. It would work perfectly on our laptop, but when we deployed it, something broke, and RAG would degrade. If we were running our own model, it would quickly become out of date. The proof-of-concept that impressed the team couldn't handle real-world data.Our solution: declarative AI-as-code. One YAML defines models, policies, data, evals, and deploy. Instead of one brittle giant, we orchestrate a Mixture of Experts—many small, specialized models you continuously fine-tune from real usage. With RAG for source-grounded answers, systems get cheaper, faster, and auditable.There’s a short demo here: <a href="https://www.youtube.com/watch?v=W7MHGyN0MdQ" rel="nofollow">https://www.youtube.com/watch?v=W7MHGyN0MdQ</a> and a more in-depth one at <a href="https://www.youtube.com/watch?v=HNnZ4iaOSJ4" rel="nofollow">https://www.youtube.com/watch?v=HNnZ4iaOSJ4</a>.Ultimately, we want to deliver a single, signed bundle—models + retrieval + database + API + tests—that runs anywhere: cloud, edge, or air-gapped. No glue scripts. No surprise egress bills. Your data stays in your runtime.We believe that the AI industry is evolving like computing did. Just as we went from mainframes to distributed systems and monolithic apps to microservices, AI is following the same path: models are getting smaller and better. Mixture of Experts is here to stay. Qwen3 is sick. Llama 3.2 runs on phones. Phi-3 fits on edge devices. Domain models beat GPT-5 on specific tasks.RAG brings specialized data to your model: You don't need a 1T parameter model that "knows everything." You need a smart model that can read your data. Fine-tuning is democratizing: what cost $100k last year now costs $500. Every company will have custom models.Data gravity is real: Your data wants to stay where it is: on-prem, in your AWS account, on employee laptops.Bottom line: LlamaFarm turns AI from experiments into repeatable, secure releases, so teams can ship fast.What we have working today: Full RAG pipeline: 15+ document formats, programmatic extraction (no LLM calls needed), vector-database embedding, universal model layer that runs the same code for 25+ providers, automatic failover, cost-based routing; Truly portable: Identical behavior from laptop → datacenter → cloud; Real deployment: Docker Compose works now with Kubernetes basics and cloud templates on the way.Check out our readme/quickstart for easy install instructions: <a href="https://github.com/llama-farm/llamafarm?tab=readme-ov-file#-quickstart-tldr" rel="nofollow">https://github.com/llama-farm/llamafarm?tab=readme-ov-file#-...</a>Or just grab a binary for your platform directly from the latest release: <a href="https://github.com/llama-farm/llamafarm/releases/latest" rel="nofollow">https://github.com/llama-farm/llamafarm/releases/latest</a>The vision is to be able to run, update, and continuously fine-tune dozens of models across environments with built-in RAG and evaluations, all wrapped in a self-healing runtime. We have an MVP of that today (with a lot more to do!).We’d love to hear your feedback! Think we’re way off? Spot on? Want us to build something for your specific use case? We’re here for all your comments!

Show HN: ElevenLabs UI shadcn/UI components for audio

Show HN: ElevenLabs UI shadcn/UI components for audio Hey hn, I put together a collection of audio and agent components for Next.js built on top of ShadCN.Hope you find this useful & let me know if there’s ant feedback a (GitHub repo will be open sourced tomorrow am)

Adding Stride Scheduling to Xv6

Show HN: Run – a CLI universal code runner I built while learning Rust

Show HN: Run – a CLI universal code runner I built while learning Rust Hi HN — I’m learning Rust and decided to build a universal CLI for running code in many languages. The tool, Run, aims to be a single, minimal dependency utility for: running one-off snippets (from CLI flags), running files, reading and executing piped stdin, and providing language-specific REPLs that you can switch between interactively. I designed it to support both interpreted languages (Python, JS, Ruby, etc.) and compiled languages (Rust, Go, C/C++). It detects languages from flags or file extensions, can compile temporary files for compiled languages, and exposes a unified REPL experience with commands like :help, :lang, and :quit. Install: cargo install run-kit (or use the platform downloads on GitHub). Source & releases: <a href="https://github.com/Esubaalew/run" rel="nofollow">https://github.com/Esubaalew/run</a> I used Rust while following the official learning resources and used AI to speed up development, so I expect there are bugs and rough edges. I’d love feedback on: usability and UX of the REPL, edge cases for piping input to language runtimes, security considerations (sandboxing/resource limits), packaging and cross-platform distribution. Thanks — I’ll try to answer questions and share design notes.

Show HN: ProcASM v1.1

Show HN: ProcASM v1.1 ProcASM is general purpose, visual programming language that I've developed. A few months ago I made a post about ProcASM v1.0 here <<a href="https://news.ycombinator.com/item?id=43892442">https://news.ycombinator.com/item?id=43892442</a>> and got some feed about the UI.So, I spent that last few months trying to improve the UI. Before, I used a GUI library, that I developed specifically for this app using SDL3, for ProcASM. I used Emscripten to port it to run in web browsers for those who wanted to try the app. Now, the front-end is written in HTML, CSS, and JavaScript to execute in a web browser. The back-end is a server that stores user's projects and handles user's requests. There is also a tutorial with text and video that will walk you through the usage of the app. My hopes are that the UI will be more approachable for those who want to try out the app.The plan going forward is to develop new software using ProcASM and blog about the details and the advantages of using ProcASM.

Show HN: DWS OS, a Plan 9 Inspired Web "OS"

Show HN: DWS OS, a Plan 9 Inspired Web "OS" Hi HN,I've always loved the aesthetic, quirks, and concepts of Plan9, and I wanted to see how far I could vibe-code a web desktop/OS that resembled it. The result is DWS OS.My goal was to reach a point where I could build "userspace" apps for this OS, in the OS. DWS OS has a virtual filesystem, an approximation of the ACME editor, file browser, internet browser (just an iframe for fun), and a few other apps to discover.The environment supports uploading and downloading data from the virtual filesystem, along with support for JavaScript programming within ACME and an API for building GUI apps within DWS OS and interacting with the OS DOM. Lastly, you can export and import the state of your OS as a JSON to share with others! Check out the `examples/` directory!I'd love to hear your feedback and suggestions and see if you build anything interesting within the OS, thanks!

A Web Framework for Zig

Show HN: Ultraplot – A succint wrapper for matplotlib

Show HN: I Built a XSLT Blog Framework

Show HN: I Built a XSLT Blog Framework A few weeks ago a friend sent me grug-brain XSLT (1) which inspired me to redo my personal blog in XSLT.Rather than just build my own blog on it, I wrote it up for others to use and I've published it on GitHub <a href="https://github.com/vgr-land/vgr-xslt-blog-framework" rel="nofollow">https://github.com/vgr-land/vgr-xslt-blog-framework</a> (2)Since others have XSLT on the mind, now seems just as good of a time as any to share it with the world. Evidlo@ did a fine job explaining the "how" xslt works (3)The short version on how to publish using this framework is:1. Create a new post in HTML wrapped in the XML headers and footers the framework expects.2. Tag the post so that its unique and the framework can find it on build3. Add the post to the posts.xml fileAnd that's it. No build system to update menus, no RSS file to update (posts.xml is the rss file). As a reusable framework, there are likely bugs lurking in CSS, but otherwise I'm finding it perfectly usable for my needs.Finally, it'd be a shame if XSLT is removed from the HTML spec (4), I've found it quite eloquent in its simplicity.(1) <a href="https://news.ycombinator.com/item?id=44393817">https://news.ycombinator.com/item?id=44393817</a>(2) <a href="https://github.com/vgr-land/vgr-xslt-blog-framework" rel="nofollow">https://github.com/vgr-land/vgr-xslt-blog-framework</a>(3) <a href="https://news.ycombinator.com/item?id=44988271">https://news.ycombinator.com/item?id=44988271</a>(4) <a href="https://news.ycombinator.com/item?id=44952185">https://news.ycombinator.com/item?id=44952185</a>(Aside - First time caller long time listener to hn, thanks!)

Ergonomic errors in Rust: write fast, debug with ease, handle precisely

ResurrectedGod: The Ruby Framework for Process Management

A robust, open-source framework for Spiking Neural Networks on low-end FPGAs

Show HN: TraceRoot – Open-source agentic debugging for distributed services

Show HN: TraceRoot – Open-source agentic debugging for distributed services Hey Xinwei and Zecheng here, we are the authors of TraceRoot (<a href="https://github.com/traceroot-ai/traceroot">https://github.com/traceroot-ai/traceroot</a>).TraceRoot (<a href="https://traceroot.ai">https://traceroot.ai</a>) 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 (<a href="https://github.com/traceroot-ai/traceroot-sdk">https://github.com/traceroot-ai/traceroot-sdk</a>) and TypeScript (<a href="https://github.com/traceroot-ai/traceroot-sdk-ts">https://github.com/traceroot-ai/traceroot-sdk-ts</a>) SDKs - they can hook into your app using OpenTelemetry and captures logs and traces. These are either sent to a local Jaeger (<a href="https://www.jaegertracing.io/" rel="nofollow">https://www.jaegertracing.io/</a>) + 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 togetherTraceRoot 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: <a href="https://www.youtube.com/watch?v=nb-D3LM0sJM" rel="nofollow">https://www.youtube.com/watch?v=nb-D3LM0sJM</a>We’d love you to try TraceRoot (<a href="https://traceroot.ai">https://traceroot.ai</a>) and share any feedback. If you're interested, our code is available here: <a href="https://github.com/traceroot-ai/traceroot">https://github.com/traceroot-ai/traceroot</a>. 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!

Show HN: Pontoon – Open-source customer data syncs

Show HN: Pontoon – Open-source customer data syncs Hi HN,We’re Alex and Kalan, the creators of Pontoon (<a href="https://github.com/pontoon-data/Pontoon">https://github.com/pontoon-data/Pontoon</a>). Pontoon is an open-source data export platform that makes it really easy to create data syncs and send data to your enterprise customers. Check out our demo here: <a href="https://app.storylane.io/share/onova7c23ai6">https://app.storylane.io/share/onova7c23ai6</a> or try it out with docker: <a href="https://pontoon-data.github.io/Pontoon/getting-started/quick-start/" rel="nofollow">https://pontoon-data.github.io/Pontoon/getting-started/quick...</a>While at our prior roles as data engineers, we’ve both felt the pain of data APIs. We either had to spend weeks building out data pipelines in house or spend a lot on ETL tools like Fivetran (<a href="https://www.fivetran.com/" rel="nofollow">https://www.fivetran.com/</a>). However, there were a few companies that offered data syncs that would sync directly to our data warehouse (eg. Redshift, Snowflake, etc.), and when that was an option, we always chose it. This led us to wonder “Why don’t more companies offer data syncs?”. It turns out, building reliable cross-cloud data syncs is difficult. That’s why we built Pontoon.We designed Pontoon to be:- Easily deployed: we provide a single, self-contained Docker image for easy deployment and Docker Compose for larger workloads (<a href="https://pontoon-data.github.io/Pontoon/getting-started/quick-start/" rel="nofollow">https://pontoon-data.github.io/Pontoon/getting-started/quick...</a>)- Support modern data warehouses: we support syncing to/from Snowflake, BigQuery, Redshift, and Postgres.- Sync cross cloud: sync from BigQuery to Redshift, Snowflake to BigQuery, Postgres to Redshift, etc.- Developer friendly: data syncs can also be built via the API- Open source: Pontoon is free to use by anyoneUnder the hood, we use Apache Arrow (<a href="https://arrow.apache.org/" rel="nofollow">https://arrow.apache.org/</a>) to move data between sources and destinations. Arrow is very performant - we wanted to use a library that could handle the scale of moving millions of records per minute.In the shorter-term, there are several improvements we want to make, like:- Adding support for DBT models to make adding data models easier- UX improvements like better error messaging and monitoring of data syncs- More sources and destinations (S3, GCS, Databricks, etc.)- Improve the API for a more developer friendly experience (it’s currently tied pretty closely to the front end)In the longer-term, we want to make data sharing as easy as possible. As data engineers, we sometimes felt like second class citizens with how we were told to get the data we needed - “just loop through this api 1000 times”, “you probably won’t get rate limited” (we did), “we can schedule an email to send you a csv every day”. We want to change how modern data sharing is done and make it simple for everyone.Give it a try <a href="https://github.com/pontoon-data/Pontoon">https://github.com/pontoon-data/Pontoon</a>. Cheers!

CAMARA: Open-source API for telecom and 5G networks

Show HN: Easy Python Time Parsing

Show HN: Easy Python Time Parsing I recently build a python time-parser that can parse most formats in a single line. Might be useful to some here. (Also happy to hear feedback and feature requests)

Gitea Private, Fast, Reliable DevOps Platform

Show HN: RULER – Easily apply RL to any agent

Show HN: RULER – Easily apply RL to any agent Hey HN, Kyle here, one of the co-founders of OpenPipe.Reinforcement learning is one of the best techniques for making agents more reliable, and has been widely adopted by frontier labs. However, adoption in the outside community has been slow because it's so hard to implement.One of the biggest challenges when adapting RL to a new task is the need for a task-specific "reward function" (way of measuring success). This is often difficult to define, and requires either high-quality labeled data and/or significant domain expertise to generate.RULER is a drop-in reward function that works across different tasks without any of that complexity.It works by showing N trajectories to an LLM judge and asking it to rank them relative to each other. This sidesteps the calibration issues that plague most LLM-as-judge approaches. Combined with GRPO (which only cares about relative scores within groups), it just works (surprisingly well!).We have a full writeup on the blog, including results on 4 production tasks. On all 4 tasks, small Qwen 2.5 models trained with RULER+GRPO beat the best prompted frontier model, despite being significantly smaller and cheaper to run. Surprisingly, they even beat models trained with hand-crafted reward functions on 3/4 tasks! <a href="https://openpipe.ai/blog/ruler">https://openpipe.ai/blog/ruler</a>Repo: <a href="https://github.com/OpenPipe/ART">https://github.com/OpenPipe/ART</a>

Show HN: Smart Switcher - data driven tool to improve the window switching

Show HN: Smart Switcher - data driven tool to improve the window switching Hello, my name is Andrew. I'm an indie developer and I'm excited to release Smart Switcher for Windows 10/11. I'm looking for feedback on the overall project and the application itself.I built this because I couldn't find a window switching/management solution that worked for me. I tried all kinds of different solutions, virtual desktop extensions, obscure GUI window managers, you name it. Overtime I realized I wanted something that prioritizes one window at a time, is keyboard driven with has minimal if no GUI elements. I figured this part out, but knew something was missing. I had my eureka moment when I realized I could combine my switching method with a prediction algorithm. This led to the creation of Smart Switcher.Smart Switcher is a data driven window switcher aimed at improving the overall window switching experience. It logs data on your windows switching, then a prediction algorithm analyzes this data and uses it to predict which window you would want to switch to next. When you need to switch windows, you press the switch shortcut to switch to the next predicted window. If this isn't the window you wanted, press the override shortcut to switch to the next most likely window. You can press the override shortcut as many times as needed until you arrive at your desired window.It’s a paid app with a demo and trial version. There is a introductory discount and some additional discount tiers for early adopters.Any feedback is appreciated! Thanks!

Show HN: Virby, a vfkit-based Linux builder for Nix-Darwin

Show HN: Virby, a vfkit-based Linux builder for Nix-Darwin Virby is a module for nix-darwin that configures a lightweight linux VM as a remote build machine for nix, allowing linux packages to be built on macOS.