标签：#open

I recently tried to share an open-source project I've been working on called Open Vectorizer . It's a raster-to-SVG vectorization engine written in Rust. It runs locally, compiles to WebAssembly, has a reproducible benchmark suite, and competes surprisingly well with established tools like Potrace and VTracer. I wanted people to see it. More importantly, I wanted contributors. That's where things got weird. First, Hacker News Open Vectorizer felt like a natural fit for Show HN. It's open source. It's technical. There's an interesting algorithm behind it. There are benchmarks people can reproduce and argue about, which I'm told is approximately 73% of Hacker News' renewable energy supply. Except I couldn't submit a Show HN. Hacker News is temporarily restricting Show HN submissions from newer users because of a large influx of people unfamiliar with the community. Fair enough. Annoying, but understandable. So I tried Reddit. Then r/rust Open Vectorizer is written in Rust, so r/rust seemed like an even more obvious place to share it. The post was automatically removed. The subreddit now requires project submissions to certify that they do not contain significant AI-generated content . And that's something I can't honestly certify. Open Vectorizer has been developed with substantial AI assistance. So I didn't repost it. Then r/opensource Surely an MIT-licensed project actively looking for contributors belongs in an open-source community. Their rules include: All AI-generated content is low-effort and ban worthy. At this point I had to appreciate the situation. I had an open-source project. I wanted humans to contribute to it. And some of the communities containing exactly those humans didn't want me to tell them about it because machines had helped write it. Here's the problem I actually understand why these rules exist. AI has made it incredibly cheap to produce software-shaped objects. You can ask an agent to build a database, publish 20,000 lines to GitHub an hour l

A while back I built a small tool called SDKProof. it checks how well an AI coding agent writes an SDK's current API — the stuff that changed in the last major, that the model tends to get wrong because it learned the old version. Claude Opus 5 came out today. so I re-ran the whole board on it. short version: it fixed last year's SDKs. it did not fix this year's. The board, now on Opus 5 Same tasks, same libraries, new model: SDK shipped its major Opus 5 Prisma 7 late 2025 (freshest) 87 Next.js 16 late 2025 92 Vercel AI SDK 7 mid 2025 100 Zod 4 2025 100 TanStack Query 5 2023 100 The way each score works: the model solves ~10–15 real tasks, the code gets type-checked against the real installed package, pass = it compiles. no LLM judging another LLM, the compiler decides. The two that jumped: Vercel AI SDK 7 and Zod 4 were both 90 on the previous model (Opus 4.8). Opus 5 took them to 100. What flipped Here's the kind of thing that changed. Define a tool with the AI SDK. Opus 4.8 wrote it the old (v4) way: const getWeather = tool ({ parameters : z . object ({ city : z . string () }), // renamed to inputSchema execute : async ({ city }) => `...` , }) await generateText ({ model , prompt , tools : { getWeather }, maxSteps : 5 , // removed }) That doesn't compile against ai v7. parameters is now inputSchema , and maxSteps is gone (it's stopWhen: stepCountIs(5) now). Opus 5 writes the current shape by itself: const getWeather = tool ({ inputSchema : z . object ({ city : z . string () }), execute : async ({ city }) => `...` , }) await generateText ({ model , prompt , tools : { getWeather }, stopWhen : stepCountIs ( 5 ), }) Clean compile. same for Zod — Opus 4.8 kept reaching for the removed required_error , Opus 5 writes the new unified error option. What didn't move Prisma 7 and Next 16 barely changed. they shipped their breaking changes most recently, and even the newest model hasn't caught up. Prisma still writes the pre-v7 client setup — it skips the driver adapter that

On the latest episode of Equity, we discussed why Moonshot AI's Kimi seemed to panic Silicon Valley and Wall Street.

How to Build and Debug MCP Servers for Claude Desktop in 5 Seconds 🔨 Model Context Protocol (MCP) by Anthropic is rapidly becoming the open standard for connecting LLMs like Claude Desktop, Cursor, and Windsurf to local dev tools, APIs, and databases. However, setting up an MCP server from scratch, configuring stdio transports, and debugging JSON-RPC requests in the terminal can be tedious. To solve this, I built mcp-forge — an open-source Swiss-Army developer toolkit and inspector for MCP servers. ⚡ What is mcp-forge ? mcp-forge gives you everything you need to build, test, inspect, and run MCP servers with zero setup overhead : 🛠️ npx mcp-forge serve : Launches a built-in suite of developer tools for Claude Desktop (Git summary, System diagnostics, Mermaid syntax validator, HTTP API tester). 🔍 npx mcp-forge inspect <cmd> : An interactive stdio inspector to connect to any MCP server, list tools/resources/prompts, and test executions live. ⚡ npx mcp-forge init <name> : Scaffolds a production-ready TypeScript MCP server in 5 seconds with TypeScript, tsup bundler, and Vitest. 🌐 npx mcp-forge ui : A visual dark-themed web dashboard for real-time WebSocket traffic monitoring. 🚀 Quickstart: Supercharge Claude Desktop in 1 Minute You don't even need to install anything globally! You can run mcp-forge directly via npx . 1. Add mcp-forge to Claude Desktop Add this snippet to your claude_desktop_config.json : { "mcpServers" : { "mcp-forge" : { "command" : "npx" , "args" : [ "-y" , "mcp-forge" , "serve" ] } } } Now Claude can automatically inspect your Git status, fetch system memory/CPU telemetry, validate Mermaid diagram syntax, and test REST endpoints! Scaffold a New MCP Server in 5 Seconds Want to build your own custom MCP server? Run: npx mcp-forge init my-awesome-mcp-server cd my-awesome-mcp-server npm install npm run dev You get a fully-typed MCP server template with @modelcontextprotocol/sdk configured and ready to publish. Inspect & Debug Any MCP Server in Terminal N

Most agent frameworks help you build a workflow. The harder part starts after that: the workflow has to run as a long-lived process, fail clearly, restart carefully, and be inspectable after the fact. That's the gap I'm building AgentOS for — an open-source, Rust-first runtime layer that sits underneath frameworks like LangGraph, AutoGen or CrewAI instead of replacing them. What one process gives you cargo run -p agentos-cli -- run --agent examples/simple_agent.toml That single command brings up a supervised agent, a health endpoint, a gRPC message bus, a live SSE event stream, and a recorded trace you can replay later. No API key is needed just to bring the runtime up. Time-travel debugging Your agent does something weird on step 7. Reproducing it costs real API calls, and it never behaves the same way twice. AgentOS journals every LLM exchange and tool result at the provider boundary, so any run can be replayed deterministically — and forked into alternate timelines: agentOS run --agent my_agent.toml # every step journaled automatically agentOS replay --session agent_123 # offline re-run, no API cost, drift-checked agentOS fork --from ckpt_4 --prompt "try the other path" The dashboard's Recordings view turns those journals into a scrubbable timeline: step through the prompt, each exchange, tool calls and their results, with per-exchange checkpoints as fork anchors. What's inside crates/kernel — lifecycle, agent handles, supervisor crates/bus — in-memory, gRPC, SSE and WebSocket messaging crates/trace — recording, replay, diff, checkpoint model crates/vault — secret isolation, encryption, scopes, audit crates/memory , crates/registry , crates/llm , crates/cli , crates/sdk dashboard/ — React debugging surface Where it honestly stands Stable enough for local use: the run / ps / logs / trace / replay CLI flows, local state inspection, export and import, and the core crates with workspace checks and tests. Still experimental: the dashboard, the WASM plugin runtime, Doc

Modern applications don't just need features—they need observability . When an API becomes slow, a database query takes too long, or an unexpected error occurs, developers need answers quickly. That's where SigNoz and OpenTelemetry come in. For the Agents of SigNoz Hackathon 2026 , I integrated SigNoz into my existing MERN Stack e-commerce application called Ram Store and transformed it into a fully observable application. In this blog, I'll walk through what I built, how I instrumented it, the challenges I faced, and what I learned. About the Project Ram Store is a full-stack e-commerce platform built using the MERN Stack. Features User Authentication Product Management Categories & Subcategories Shopping Cart Address Management Order Management MongoDB Database Tech Stack React (Vite) Node.js Express.js MongoDB Docker OpenTelemetry SigNoz Winston Logger Why Observability? Before integrating SigNoz, I could only rely on: console.log() Manual debugging Browser Network tab When something failed, I had questions like: Which API is slow? Why is the response delayed? Which MongoDB query is taking time? How many requests is my backend serving? Where exactly did the error happen? Without observability, finding answers takes time. I wanted a single place where I could monitor everything. That's why I chose SigNoz . Setting Up SigNoz I self-hosted SigNoz locally using Docker. Once all the containers were running successfully, the dashboard became available. After the initial setup, the next step was instrumenting my backend. Integrating OpenTelemetry I added OpenTelemetry to my Node.js backend. Using the Node SDK together with automatic instrumentation, I configured: Express instrumentation HTTP instrumentation MongoDB instrumentation OTLP gRPC exporter Now every request automatically generates telemetry without modifying every route. Distributed Traces One of my favorite features is Distributed Tracing . Whenever I perform an action in Ram Store—like opening products or ad

I spent a week trying to answer one question about my own AI agents: when one of them does something stupid in production, how do I prove the fix worked? For normal software the answer is boring. You have monitoring, an incident, a regression test, a staged rollout. For an agent you usually have a trace viewer and a shrug. So I built ArcNet on self-hosted SigNoz for the Agents of SigNoz hackathon, and most of what I learned was about SigNoz internals I could not have guessed from the docs. Here are the parts that cost me real time. The setup The stack is small. Agents run on Agno. An in-process SDK wraps them and does two jobs: OpenTelemetry instrumentation, and guardrails from unplug-ai at four checkpoints (input, retrieved content, tool call, output). Traces go to self-hosted SigNoz over OTLP. A FastAPI server reads back out of SigNoz, and a React UI sits on top. Installing SigNoz was the easiest part, which surprised me. Foundry takes one file: apiVersion : v1alpha1 kind : Installation metadata : name : signoz spec : deployment : flavor : compose mode : docker signoz : spec : image : signoz/signoz:v0.133.0 foundryctl cast -f casting.yaml That brings up SigNoz and its MCP server together and writes a casting.yaml.lock with checksums. I committed the lock file, and re-running foundryctl forge against it later produced a byte-identical file. That is a genuinely nice property for a hackathon judge or a teammate. Lesson 1: check what your instrumentor actually emits This is the one I would tell everyone. I assumed Agno instrumentation would produce OpenTelemetry's gen_ai.* semantic conventions, because that is what the GenAI spec describes. I started sketching dashboard queries against gen_ai.usage.input_tokens before anything was running. Then I turned it on. openinference-instrumentation-agno emits OpenInference conventions, which are a different attribute set. The spans I actually got were shaped like this: agent_j.run └── gpt-5.6-luna.invoke └── search_tickets Eve

Let me start with a question. If a stranger handed you a USB drive and said "plug this in, it just...

"The first autonomous agent cyberattack is an unprecedented event. It deserves an unprecedented response!"

Most AI diagram workflows end with a PNG or a screenshot. It may look fine, but the moment the architecture changes, you have to redraw it or regenerate the whole image. I wanted a different workflow: describe a system in natural language, receive a real Draw.io file, and keep editing every node, label, connector, group, and icon. That is why I built drawio-mxgraph , an open-source Codex Skill that turns architecture and process descriptions into validated, editable .drawio files. Repository: https://github.com/clawcode3-bit/drawio-mxgraph-skill What the Skill does The Skill generates mxGraph XML that opens directly in Draw.io/diagrams.net. It is designed for architecture diagrams, business processes, agent workflows, and integration maps. Key capabilities include: Natural-language descriptions to editable .drawio XML Stable node IDs for reliable incremental updates Add, remove, move, resize, rename, and regroup operations Layout direction switching: left-to-right, right-to-left, top-to-bottom, or bottom-to-top Orthogonal connector routing with explicit entry and exit points Portable embedded SVG icons, including cloud and enterprise-style icon sets XML structure and reference validation before delivery Example diagrams that can be opened and modified immediately Why stable IDs matter A common failure mode in generated diagrams is treating every edit as a full redraw. That makes small requests surprisingly destructive. With stable IDs, a request such as: Move the ticketing system below the CRM, add an observability group, and change the layout to left-to-right. can update only the affected cells. Existing labels, styles, icons, connections, and manually adjusted positions can remain intact. This makes the diagram behave more like source code than a disposable image. Example: an AgentBuilder customer-service architecture The repository includes an editable example for an intelligent customer-service system built with AgentBuilder. It connects: Web, mobile, messaging,

GitHub热门项目 | The Cyber Swiss Army Knife - a web app for encryption, encoding, compression and data analysis | Stars: 35,443 | 77 stars this week | 语言: JavaScript

GitHub热门项目 | Simple, Fast, Code first and Compile time generated OpenAPI documentation for Rust | Stars: 3,983 | 8 stars today | 语言: Rust

GitHub热门项目 | You're the boss, agents are your team. They handle tasks on their own, message each other, and review each other's work. You just watch the kanban board and give high-level commands. Codex/Claude/OpenCode/Cursor/Grok/GitHub Copilot/Kiro/Z.AI/MiniMax/Kimi(200+ models, 75+ LLM providers, free models no auth). Build your AI company with multiple teams | Stars: 1,680 | 23 stars today | 语言: TypeScript

GitHub热门项目 | A progressive Node.js framework for building efficient, scalable, and enterprise-grade server-side applications with TypeScript/JavaScript 🚀 | Stars: 76,210 | 15 stars today | 语言: TypeScript

GitHub热门项目 | Free AI with your ChatGPT account | Stars: 933 | 109 stars today | 语言: TypeScript

GitHub热门项目 | MCP servers for the UniFi suite of applications, Network, Protect, Access, and Drive | Stars: 579 | 14 stars today | 语言: Python

GitHub热门项目 | 🔥🔥🔥 AI-driven database tool and SQL client, The hottest GUI client, supporting MySQL, Oracle, PostgreSQL, DB2, SQL Server, DB2, SQLite, H2, ClickHouse, and more. | Stars: 26,906 | 399 stars today | 语言: Java

Hey folks 👋 If you've ever wanted to save a video lecture, a livestream replay, or a podcast episode for offline listening, you've probably run into the usual options: sketchy "online video parser" websites that ask you to paste your link into their server, or desktop apps that want you to sign up and upload stuff. Neither feels great when the whole point is your content. I went looking for something better and ended up working with FlowPick — an open-source, privacy-first media downloader that runs entirely in your browser. No uploads, no accounts, no telemetry. Everything (sniffing, downloading, merging, transcoding) happens client-side with FFmpeg compiled to WebAssembly. In this tutorial we'll: Clone and run FlowPick locally Download our first HLS ( .m3u8 ) and DASH ( .mpd ) stream Build and deploy it Poke at the internals so we can customize it If you just want to try it without installing anything, there's a hosted version at https://flowpick.net (more below). The full source is on GitHub: https://github.com/ezwebtools/flowpick . 🔗 Repo: https://github.com/ezwebtools/flowpick · Live tools: https://flowpick.net A 30-second primer: what are HLS and DASH? Before we touch code, two words you'll see everywhere in this space: HLS (HTTP Live Streaming) uses a .m3u8 manifest that lists small .ts (or fMP4) segments. Common for live streams and a lot of video platforms. DASH (Dynamic Adaptive Streaming over HTTP) uses a .mpd manifest; video and audio usually travel as separate .m4s tracks. YouTube and Bilibili lean on this. The key idea: the "video" isn't one file. It's a playlist pointing at dozens (sometimes hundreds) of tiny segments. A downloader's job is to fetch all the segments, decrypt them if needed, and stitch them back into one playable file. That's exactly what FlowPick does — in the browser. What FlowPick is, in one paragraph FlowPick is a Nuxt 4 app that ships in two shapes: A browser extension that sniffs media from the current tab's network requests. An

Nobody has ever asked you to upstream your dotfiles. For thirty years that was the deal with every tool we touched: if you didn't like it, you changed it, and the change lived with you. Then the tools started writing the code, and the deal quietly ended. This essay is about why the deal is back on the table. Because the thing that used to make forking expensive — the labour — is exactly what agents just made cheap. In This Article The Workbench Instinct Then the Harness Era Arrived Forking Was Always the Escape Hatch Code Got Cheap What I Shipped Into My Fork A Feature Does Not Have to Be Useful Your Desire Is the Limit The Fork Is the Destination Now the Discipline Part Bring Back the Joy The Workbench Instinct Show me a developer who has never touched their config and I'll show you someone who hasn't started yet. Vim users brag about their init.lua the way woodworkers talk about a hand plane they've had for twenty years. Emacs people wrote a whole operating system inside a text editor because they could. VS Code won partly because it shipped an extension API and got out of the way. Dotfiles repos are public artifacts, starred and forked, because the setup is part of the craft. This isn't productivity theatre. Some of it is genuine need, some of it is fixing a specific annoyance that only you have, and a lot of it is just fun. All three are valid. The workbench is where the joy lives — and nobody ever waited for permission to alias a command. Then the Harness Era Arrived Then agentic coding tools showed up and quietly changed the shape of the deal. The best-in-class agent harnesses are increasingly vendor-controlled. Claude Code is a product, not a repo you can clone and rebuild. Google announced it's retiring Gemini CLI in favour of a closed-source successor. And note where the line falls: Codex CLI is Apache-2.0 and sitting right there on GitHub, but the Codex desktop app — the thing most people actually click on — is not. The terminal stayed open. The interface

Video transitions are one of those details that quietly shape the feel of an edit. In Reel Quick issue #13 , the goal was simple: let users control how long a scene transition lasts instead of forcing a fixed value. Issue URL: https://github.com/ronin1770/reel-quick/issues/13 The problem The app already supported transition effects between scenes, but the duration was fixed. That meant creators could choose what transition to use, but not how long it should run. For short-form video, that matters a lot: fast transitions create a snappier pace longer transitions feel smoother or more cinematic some edits need no transition at all The feature The new behavior adds a configurable transition duration: minimum: 0.0 seconds maximum: 4.0 seconds step: 0.5 seconds A slider in the frontend lets the user choose the duration, and that value is sent to the backend for FFmpeg video generation. If the value is 0.0 , transitions are disabled entirely. The FFmpeg math When two clips are joined with a transition, the transition overlaps the end of the first clip and the start of the second clip. So the final duration is: final length = clip 1 + clip 2 - transition duration Example 1 Clip 1 = 7 seconds Clip 2 = 8 seconds Transition duration = 4 seconds Math: 7 + 8 - 4 = 11 seconds Final video length: 11 seconds Example 2 Clip 1 = 7 seconds Clip 2 = 8 seconds Transition duration = 0.5 seconds Math: 7 + 8 - 0.5 = 14.5 seconds Final video length: 14.5 seconds Why validation matters This feature also needs guardrails. The backend validates that: the duration is between 0 and 4 the duration is a multiple of 0.5 clips are long enough for the selected transition That last point is important. A 4 second transition cannot work safely if a clip itself is only 3 seconds long. Implementation notes The implementation touches both frontend and backend: Frontend add a transition duration slider show the selected value beside it send transition_duration in the video creation request show inline vali