Loading…
Topic
Open Source
561 posts about Open Source. Every summary links to the original.
- 561 posts
- 36 companies
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
Posts
AI needs the best-of-breed data stack: Postgres and ClickHouse
AI-native applications generate large volumes of operational data, while agents and users increasingly require real-time answers from that data. This pressure raises both query concurrency and reliability requirements, with a cited sample of companies using Postgres and ClickHouse showing more than 1,000% data growth in six months and over 85 TB added. The proposed stack assigns Postgres low-latency transactional workloads and ClickHouse real-time analytics, connecting them through PeerDB and ClickPipes CDC with single-digit-second replication, pg_clickhouse query pushdown, and pg_stat_ch telemetry streaming. The conclusion is that AI makes the OLTP/OLAP distinction more important, favoring an open best-of-breed stack over a single platform while preserving each database's specialized role.
Develop Humanoid Robot Policies End-to-End with NVIDIA Isaac GR00T
Humanoid robotics development suffers from fragmented tooling, siloed software ecosystems, and incompatible data formats that hinder reproducible workflows. NVIDIA introduced the Isaac GR00T Development Platform, an open-source, modular humanoid development environment that connects simulation setup, demonstration capture, policy training, evaluation, and hardware deployment. Central to this platform is the Isaac GR00T 1.7 vision-language-action model, which features a 3-billion-parameter base checkpoint licensed under Apache 2.0. The architecture adopts a Cosmos-Reason2-2B backbone and supports full pipeline export to ONNX and TensorRT for deployment on Jetson Thor. In a reference pick-and-place manipulation task, developers capture teleoperated demonstrations with Isaac Teleop, convert trajectories into LeRobot format, post-train GR00T 1.7, and evaluate the closed-loop policy inside Isaac Lab-Arena.
Introducing uFowarder: The Consumer Proxy for Kafka Async Queuing
Uber introduces uForwarder, an open-source Consumer Proxy for Kafka Async Queue workloads, after deploying a push-based system across more than 1,000 consumer services. The proxy fetches messages through Kafka’s binary protocol, sends them individually to consumer services over gRPC, collects status codes and processing results, and commits offsets when safe. Production challenges included head-of-line blocking from messages that fail before reaching handlers, growing hardware costs, external data sources that are not ready when events arrive, and requirements for production/non-production and zone isolation. The implemented solutions include context-aware routing through message and gRPC headers, active blocking detection and mitigation, hardware-efficiency improvements, and DelayProcessManager, which pauses only delayed partitions and guarantees at-least delay rather than exact timing. The project is open source, with planned work on consumer-lag handling and direct Protobuf support.
Announcing our $800M Series C to accelerate the shift to open-source AI
Together AI announces an $800M Series C to accelerate its open-source AI platform as production demand for inference grows. The company says the round includes $800 million from investors including Aramco Ventures, NVIDIA, Vista Equity, General Catalyst, and others, plus commitments for more than 500 MW of compute capacity to be capitalized independently by new investors. Together argues that closed frontier-model economics become unsustainable as agents and workflows scale, while open-weights models such as DeepSeek, Nemotron, MiniMax, Kimi, and GLM can provide equal or better performance at lower cost. Its full-stack approach spans models, kernels, compilers, inference systems, training infrastructure, hardware utilization, and software, with cited work including FlashAttention-4, Together Megakernel, together.compile, and expanded post-training APIs for tool calling, reasoning, and vision-language models.
ML Development in VS Code with Google Cloud Power: Workbench Extension Now Available
Google Cloud has launched the Google Cloud Workbench Notebooks extension for VS Code, allowing developers to use managed cloud notebook environments from a local IDE. Workbench, described as a managed Jupyter platform optimized for data science, can provide access to Google Cloud's AI-optimized infrastructure and high-performance compute when local machines need more capacity. The workflow connects through VS Code's Extensions view, the Jupyter extension, and a notebook's Select Kernel menu, where users choose Google Cloud, Workbench, authenticate, select a project, and choose an active instance. The extension runs notebooks on Workbench instances, preserves local settings and extensions, is fully open-sourced, and is available through the VS Code Marketplace, with GitHub contributions invited.
Designing GPU-Accelerated Query Engines with NVIDIA GQE
GPU-accelerated query engines encounter performance constraints stemming from memory and I/O bandwidth limitations. NVIDIA introduces GQE, a reference architecture using NVIDIA cuDF, nvCOMP, and other CUDA-X libraries to accelerate SQL query execution across modern hardware like the NVIDIA GB200 NVL4. The architecture coordinates three distinct layers: a query layer consuming Substrait plans, a data layer managing in-memory table transfers, and an execution layer executing relational operator task graphs. GQE employs pipeline parallelism, partition pruning, hybrid compression, and batched asynchronous transfers to overlap data movement with GPU compute. On a non-standard 1 TB TPC-H benchmark, GQE on a single B200 GPU achieved a 7.5x total execution time speedup over dual-socket CPU configurations running DuckDB.
10 Years of Meta’s Commitment to Python
Meta has marked ten consecutive years as a sponsor of the Python Software Foundation (PSF) to ensure the language remains robust and sustainable. Python represents the most widely used programming language across Meta's infrastructure, powering applications like Instagram and Threads as well as internal AI research. Beyond financial backing, Meta engineers actively contribute core language features, author Python Enhancement Proposals (PEPs), and build open-source tools such as the Pyrefly type checker. Company sponsorship directly funds the PSF's Developer-in-Residence program, core infrastructure, and security enhancements for the Python Package Index (PyPI). Continued support of the PSF functions as a strategic investment in maintaining the stability of the broader open-source ecosystem.
Agentic Coding on Supabase with OpenCode
Supabase has made its OpenCode integration available, connecting an AI coding agent to Supabase account and project management APIs and bundled Supabase skills. Users invoke /supabase, authenticate, and, for database, Edge Functions, logs, and other project-scoped capabilities, are guided through connecting Supabase MCP; the integration requires OpenCode 1.3.4 or later. It can list organizations and projects, create projects, open the MCP setup flow, monitor agent activity in real time, and let agents query data, check logs, and deploy functions, while the plugin is open source. The post demonstrates the workflow in Minecraft, where OpenCode connected through MCP, created and populated a table, and deployed an Edge Function on a real Supabase project.
Deploy a Production-Ready NVIDIA AI-Q Blueprint on Oracle Cloud Infrastructure
The NVIDIA AI-Q Blueprint operates as an open-source reference architecture for long-horizon agents built upon LangChain Deep Agents and the NVIDIA NeMo Agent Toolkit. Deploying this multi-agent system on Oracle Cloud Infrastructure requires coordinating foundational cloud infrastructure with containerized application workloads across Kubernetes. The deployment methodology utilizes Terraform to provision network isolation, an enhanced OKE cluster, a flexible public load balancer, and an AES-256 encrypted OCI Vault. Helm manages the application layer on Kubernetes by pulling official images from the NGC registry to run a FastAPI agent backend, a Next.js web frontend, and PostgreSQL. This configuration establishes an extensible routing architecture where user queries route automatically between shallow search agents and deep planning sub-agents while maintaining clean infrastructure teardown commands.
Creating the NVIDIA Nemotron 3 Ultra NVFP4 Checkpoint with NVIDIA Model Optimizer
Moving large model weights efficiently requires quantization, but mapping weights to NVFP4's eight positive values risks severe precision loss or outlier-induced underflow. To address this, NVIDIA quantized the 550B Nemotron 3 Ultra model using NVIDIA Model Optimizer with a multi-precision strategy rather than quantizing all layers uniformly. The recipe applies four-over-six adaptive block scaling to Mixture of Experts routed weights, while assigning FP8 to shared experts and retaining BF16 for sensitive attention linears and embeddings. This process reduced the checkpoint size from 1,121 GB down to 352.3 GB and enabled single-checkpoint execution across Hopper using W4A16 and Blackwell using native W4A4. As a result, the model achieves up to 5.9x higher inference throughput than the GLM-5.1 754B FP4 model on decode-heavy workloads while matching BF16 benchmark accuracy.
How I hunt for vulnerabilities with AI
The author describes using AI-assisted code review to hunt for vulnerabilities in ClickHouse, a large C++ codebase, despite having limited bug-bounty experience. GitHub Copilot, Claude, ChatGPT, and Gemini models were used to inspect code, generate vulnerability hypotheses, explain unfamiliar subsystems, and identify older or newly introduced attack surfaces. Promising ideas were recorded, then investigated with Python scripts against a locally running ClickHouse Docker container, followed by manual review and reproduction to distinguish genuine findings from hallucinations and misconfigurations. The work produced a few real vulnerabilities that were reported to ClickHouse’s security team and bug bounty program, while the broader conclusion is that AI can accelerate exploration and validation but still requires persistent questioning and human verification.
Announcing Silk: a silky smooth fiber runtime for ClickHouse
Silk is a C++ stackful-fiber library and scheduler created for ClickHouse’s highly concurrent, I/O-bound components, including object-storage I/O, distributed cache lookups, replica coordination, and HTTP fan-out. Its design combines one pinned OS scheduler thread per CPU, NUMA-aware work stealing, io_uring for asynchronous I/O and timers, and zero heap allocation in the steady-state hot path; fiber stacks are mmap’d from per-fiber pools with guard pages, while runtime containers are intrusive. The post reports benchmarks including roughly 3.6-nanosecond fiber yields with cross-CPU stealing, 5.9 million file IOPS in a working configuration, and about fifteen times boost::asio’s throughput at one connection. At 10,000 concurrent S3-style requests, internal measurements showed a roughly 65% improvement in 99.9th-percentile latency versus an equivalent thread-pool executor, with identical median throughput; distributed cache is the first intended ClickHouse integration.
How we used DSPy to turn AI evaluations into better responses in Dash chat
Dropbox improved its Dash chat agent by establishing an automated optimization loop powered by DSPy and LLM-as-judge evaluations. Engineers first calibrated their LLM judges against human-annotated interaction traces, then used those judges to systematically optimize the agent's system prompts via offline counterfactual replay. This automated workflow reduced incomplete responses by 26% while decreasing overall token consumption.
Why we rewrote WAL-G for Postgres backups in Rust: Meet WAL-RUS
ClickHouse Cloud built WAL-RUS, an open-source Rust implementation of PostgreSQL backup and WAL archival tooling, after encountering difficulty predicting WAL-G’s memory usage in resource-constrained environments. The project preserves WAL-G’s core functionality and compatibility while using bounded worker pools, controlled concurrency, persistent object-storage connections, and a streaming pipeline that limits buffering and data copies. It uses the same WALG_ configuration variables, and WAL-G and WAL-RUS can read each other’s archives. In a sustained WAL-heavy benchmark with four archival workers, WAL-RUS stayed below 1 GB of peak virtual memory versus nearly 2.8 GB for WAL-G, while both maintained minimal backlog and comparable CPU usage. The authors plan to make WAL-RUS the default backup and archival mechanism for ClickHouse Cloud’s managed Postgres offering and are working to upstream its Postgres 17 wal summaries support to WAL-G.
How Visa went from multi-day reporting to conversational analytics agents with ClickHouse Cloud and LibreChat
Visa used ClickHouse Cloud to modernize reporting on Authorize.net payments data, replacing multi-day analyst-led turnaround with natural-language queries for internal teams. The solution pairs LibreChat, an open-source conversational interface, with the ClickHouse MCP server and runs on ClickHouse Cloud on AWS, allowing agents to explore and query a roughly 40 PB data footprint containing millions of rows. ClickHouse materialized views pre-compute and incrementally update results, reducing scanned data and bringing example analyses down to 100–200 milliseconds, with reported speedups of roughly 30–70 times. The platform also uses encrypted transfers, Amazon S3, VPC PrivateLink, change data capture, and federated access controls, while Visa reports identifying millions of dollars in revenue risk and reclaiming 8–10 hours per user each week.
NilAway: Practical Nil Panic Detection for Go
NilAway is Uber’s static analyzer for detecting potential nil pointer dereferences in Go before they reach production, where nil panics have caused incorrect behavior, outages, and denial-of-service risks. It models nilability flows as global typing constraints over struct fields, function parameters, and return values, builds an implication graph, and uses 2-SAT-style reasoning with forward nilness and backward nonnil propagation to identify contradictions. The analysis is interprocedural, requires no developer annotations, and reports detailed flows, while acknowledging false positives when runtime invariants are not captured. In one Uber service logging more than 3,000 nil panics daily, NilAway identified a receive-from-closed-channel path; adding a nilness check reduced the reported panics to zero, and the tool was released as open source with comprehensive and changed-code onboarding options.
Boost Inference Performance up to 15x on NVIDIA Blackwell Using DFlash Speculative Decoding
Sequential token generation in autoregressive LLMs limits GPU utilization and serving throughput, while conventional speculative decoding remains constrained by autoregressive draft models. DFlash addresses this bottleneck by employing a lightweight block-diffusion drafter that predicts an entire block of masked candidate tokens in a single forward pass. The architecture incorporates target hidden-state conditioning and key-value injection into draft model projections while relying on the target model for parallel verification. Evaluated on NVIDIA Blackwell GPUs across TensorRT-LLM, vLLM, and SGLang, DFlash increases gpt-oss-120b throughput by more than 15x at high interactivity targets and delivers up to 5.8x speedups on Gemma 4 31B compared to autoregressive decoding.
Shipping huggingface_hub every week with AI, open tools, and a human in the loop
huggingface_hub, the Python client underlying libraries such as transformers, datasets, diffusers, and sentence-transformers, moved from releases every four to six weeks to a weekly cadence. A single manually triggered GitHub Actions workflow now computes versions, manages branches, tags and publishes both huggingface_hub and the hf CLI, creates downstream RC test branches, and handles post-release tasks. An open-weights model drafts structured release notes and Slack announcements using PR metadata and documentation diffs, while OpenCode, HF Inference Providers, PyPI Trusted Publishing, and pinned, checksum-verified tooling provide the stack. Deterministic manifest validation checks missing or extra PR references, then a human reviews and publishes the drafts. The reported result is weekly shipping at about $0.25 per full release, with more consistent notes, earlier downstream breakage detection, and shorter contributor feedback loops.
PP-OCRv6 on Hugging Face: 50-Language OCR from 1.5M to 34.5M Parameters
PP-OCRv6 is PaddleOCR’s latest universal OCR model family, targeting text detection and recognition across documents, screenshots, displays, labels, and scene text. It offers tiny, small, and medium tiers spanning 1.5M to 34.5M parameters, while the small and medium tiers support 50 languages. Its PPLCNetV4 backbone is shared across detection and recognition, with RepLKFPN for lightweight multi-scale detection and EncoderWithLightSVTR for recognition using local context and global attention. On PaddleOCR’s official in-house multi-scenario benchmarks, PP-OCRv6_medium reaches 86.2% detection Hmean and 83.2% recognition accuracy, improving over PP-OCRv5_server by 4.6 percentage points and 5.1 percentage points. PaddleOCR provides Paddle Inference, Transformers, and ONNX Runtime paths, and results can be saved as visualization images or structured JSON for downstream workflows.
We got local models to triage the OpenClaw repo for FREE!*
OpenClaw receives hundreds of issues and pull requests daily, creating a triage problem for maintainers who need near-real-time filtering without consuming a paid closed-model quota. The system uses Gemma and Qwen local models inside a Pi-based agent harness: each item is normalized, enriched with GitHub context, classified into finite topic labels, and required to return structured output. For pull requests, the agent can inspect the repository through reposhell, a read-only command-restricted shell, while localpager, SQLite, a worker queue, and deterministic notification policy handle orchestration and Discord delivery. Tests described for gemma-4-26b-a4b and qwen3.6-35b-a3b report hundreds of tokens per second and good zero-shot classification accuracy without fine-tuning, while an LLM audit loop monitors errors; the authors present the pattern as agentic classification for high-throughput triage.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.