Loading…
Topic
Open Source
563 posts about Open Source. Every summary links to the original.
- 563 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
ClickHouse Release 26.2
ClickHouse version 26.2 introduces twenty-five new features, forty-three performance optimizations, and one hundred eighty-three bug fixes across the database engine. This release graduates both the text-index and the QBit vector embedding data type to production-ready status for search and retrieval workloads. For streaming ingestion pipelines where row arrival rates are low, the engine adds time-based block flushing configurations to write data parts before hitting default row or byte thresholds. The update also embeds the ClickStack observability user interface directly into the standard binary distribution, accessible through the local HTTP server port. Further enhancements include automatic min-max indexing for temporal columns in MergeTree tables, interactive time-based one-time password authentication in the client, and a high-performance prime number generator function.
Observability and OpenTelemetry: Introducing MongoDB Atlas Log Integration
During database latency spikes or unexpected outages, operations teams frequently waste valuable time downloading compressed archives and manually inspecting log files to isolate root causes. MongoDB Atlas resolves this operational friction by introducing a direct log integration feature for dedicated M10+ clusters. The system routes mongod, mongos, and audit logs directly to third-party tools such as Datadog, Splunk, Amazon S3, Google Cloud Storage, and Azure Blob Storage. Furthermore, built-in support for the OpenTelemetry standard enables teams to pipe database logs into any OTel-compatible logging backend. This setup eliminates operational silos, streamlines security auditing, and correlates database query diagnostics with application traces and infrastructure metrics in real time.
What's new in ClickStack. February '26.
ClickStack introduced several platform updates and query performance enhancements across both open-source and Cloud environments for February 2026. ClickHouse Cloud OpenAPI now exposes ClickStack resources including dashboards, alerts, sources, and webhooks to support automated configuration-as-code workflows. In addition, ClickHouse 26.2 embeds the ClickStack UI directly into the database binary with a 4.1 MB footprint for local exploration and diagnostics. Visualizations now support native SQL mode for tables, allowing users to join disparate datasets like logs and traces across injected dynamic time variables. Finally, query execution speeds improve through streaming skip indexes, index pruning on disjunctions, and an expanded 100,000-row lazy materialization limit alongside new threshold alerting on number charts.
GitTrends: A Google Trends style view of the GitHub ecosystem
GitHub produces billions of events across issues, pull requests, and comments, but turning this vast stream into a real-time trends analyzer presents significant technical challenges. GitTrends is an open-source demo application designed to search and compare technology keywords across nearly ten billion GitHub events. Built to showcase the full-text search capabilities recently released in ClickHouse, the application indexes raw text without pre-computed answers or intermediate data transformation. ClickHouse executes full-text searches and aggregations within a single engine in one pass, eliminating cross-system joins and data movement. The demo includes live comparisons toggling between full-text search, bloom filters, and full table scans to illustrate query performance at scale.
LeRobot v0.5.0: Scaling Every Dimension
LeRobot v0.5.0 is a major release that expands supported hardware, policies, datasets, simulation, and its software foundation, following more than 200 merged PRs and more than 50 new contributors since v0.4.0. It adds full Unitree G1 humanoid support for locomotion, manipulation, teleoperation, and whole-body control, alongside OpenArm, Earth Rover, CAN-bus motor controllers, and other integrations. The policy additions include Pi0-FAST's autoregressive VLAs with FAST action tokenization, Real-Time Chunking for continuously blended predictions, Wall-X, X-VLA, SARM, and PEFT fine-tuning. For data and simulation workflows, streaming video encoding removes waits between recording episodes, while EnvHub loads environments from the Hugging Face Hub and IsaacLab-Arena supplies GPU-accelerated simulation. The codebase now requires Python 3.12, uses Transformers v5, supports installable third-party policy plugins, and adds remote Rerun visualization plus installation and documentation improvements.
Introducing Modular Diffusers - Composable Building Blocks for Diffusion Pipelines
Modular Diffusers introduces a composable alternative to Diffusers’ existing DiffusionPipeline for building diffusion workflows from reusable blocks. A ModularPipeline can load a workflow definition, load model components separately with settings such as bfloat16, and preserve the familiar inference API, while blocks for text encoding, image encoding, denoising, and decoding can be inspected, run independently, or rearranged. Custom Python blocks declare components, inputs, outputs, and computation logic; the example adds a Depth Anything V2 depth processor to a Qwen Image ControlNet workflow, with data flowing between compatible blocks. Blocks and complete pipelines can be published to the Hub, and Mellon can generate node interfaces from their consistent definitions. The post presents the system as an early, flexible direction and says Mellon is not ready for production use.
Introducing ClickStack embedded in ClickHouse
ClickHouse 26.2 introduces an embedded distribution of the ClickStack observability UI packaged directly inside the ClickHouse binary. Designed for local exploration and instance inspection, this distribution allows developers to visualize internal query logs, traces, and system metrics without deploying external services. To preserve build integrity and keep the added binary footprint around 4.1 to 4.2 MB, the team avoided a Node.js dependency by embedding a pre-built static Next.js application using CMake-generated C++ structs. Supporting components such as MongoDB, Express, and the Pyodide WebAssembly runtime were omitted, disabling alerting and persistent dashboards in favor of simplicity. Users can access the interface directly over HTTP to monitor local databases and query performance out of the box.
PRX Part 3 — Training a Text-to-Image Model in 24h!
PRX Part 3 reports a 24-hour speedrun for training a text-to-image diffusion model, combining techniques that performed well in earlier experiments under a budget of about $1,500 on 32 H200 GPUs. The recipe uses x-prediction in pixel space with 32-pixel patches and a 256-dimensional initial bottleneck, followed by LPIPS and DINOv2 perceptual losses, TREAD token routing, REPA alignment with DINOv3, and Muon for matrix parameters while Adam handles the rest. Training ran for 100,000 steps at 512px with batch size 1,024, then 20,000 steps at 1024px with batch size 512 and no REPA, across three synthetic datasets. The resulting model is described as usable, with strong prompt following and consistent aesthetics, though texture glitches, anatomy issues, and difficulty with hard prompts remain. The post attributes these limitations mainly to undertraining and limited data diversity and presents the recipe as a foundation for further scaling.
2,000 robots walk into a shop: Simulated A/B testing (2026) - Shopify
Shopify’s SimGym addresses the difficulty of evaluating storefront changes when merchants lack enough traffic for conventional A/B tests, by simulating shopping sessions with LLM-guided robots. Each robot runs in a cloud Chromium browser with a persona, budget, and intent, while a counterpart tests the alternate theme; the system uses real page representations rather than a mocked DOM. To support bursty, sequential workloads with 89K–127K accumulated tokens per session, Shopify self-hosted gpt-oss-120b on 48 NVIDIA B200 GPUs, combining MXFP4 expert quantization, FP8 KV-cache, FlashInfer kernels, async scheduling, and guided decoding. Production measurements report 80K to 88K tokens/second per B200 from async scheduling, a 57% reduction in HTTP/gRPC overhead, and MIG experiments yielding about 20% lower latency and 12% higher daily throughput without quality regression; speculative decoding is validated but queued.
Mixture of Experts (MoEs) in Transformers
Mixture of Experts (MoEs) in Transformers let a Transformer retain its backbone while replacing selected feed-forward layers with routed expert sub-networks, allowing total model capacity to exceed the active parameters used per token. The post explains why sparse models can reduce inference cost and memory pressure, then focuses on making them first-class in Transformers. Its weight-loading refactor converts independently serialized expert tensors into packed runtime layouts through composable WeightConverter operations and lazy materialization. The Experts Backend supplies eager, batched_mm, and grouped_mm execution strategies, while expert parallelism shards experts across devices and aggregates partial outputs. Training support uses grouped GEMM and custom Triton plus LoRA kernels, with reported improvements of approximately 12× speed, over 35% VRAM reduction, and roughly 6× longer context.
GGML and llama.cpp join HF to ensure the long-term progress of Local AI
Hugging Face announces that GGML, the creators of llama.cpp, are joining the company to support the ggml and llama.cpp community as local AI advances. Georgi Gerganov and his team will continue dedicating 100% of their time to maintaining llama.cpp, retaining autonomy and leadership over its technical direction and community, while the project remains fully open-source and community driven. The technical focus is tighter integration between llama.cpp’s local-inference stack and Transformers’ model definitions, aiming to make shipping new models from Transformers’ “source of truth” nearly single-click, alongside better packaging and user experience for ggml-based software. The longer-term goal is an efficient inference stack that runs on devices and helps make open-source superintelligence accessible, with llama.cpp becoming ubiquitous and easier for casual users to deploy and access.
One-Shot Any Web App with Gradio's gr.HTML
The post presents Gradio 6’s gr.HTML as a way to build interactive web components in a single Python file, combining custom HTML templates, scoped CSS, and JavaScript interactivity without a separate build step. It describes applications including a Pomodoro timer, contribution heatmap, Kanban board, spinning wheel, and machine-learning viewers for detection, 3D camera control, and speech transcription. Within the component API, ${value} injects Python state into the template, props.value updates that state from JavaScript, and trigger('change') synchronizes it back to Python; CSS keyframes and native HTML5 drag events supply richer behavior. For reuse, a gr.HTML subclass packages the templates and script so the result can be used like built-in Gradio components, while reload mode and Spaces deployment support rapid iteration from generated code to a live app.
Building a Movie Recommendation Engine with Hugging Face and Voyage AI
Traditional movie search mechanisms depend on coarse filters such as genre, actor, or title, which fail to capture emotional context and narrative nuances. This guide demonstrates building a mood-based semantic recommendation system by combining the voyage-4-nano open-weights embedding model, Hugging Face datasets, and MongoDB Atlas Vector Search. The architecture uses Sentence Transformers to generate embeddings and exposes an endpoint through FastAPI to match user moods against movie plots. Truncating the Matryoshka embeddings from 2048 to 1024 dimensions balances semantic retrieval quality, storage footprint, and query latency. Testing shows that while abstract emotional queries return moderate similarity scores around 0.62 to 0.67, concrete descriptive queries exceed 0.75 without requiring exact keyword matches.
Custom Kernels for All from Codex and Claude
Writing CUDA kernels that integrate with diffusers and transformers involves GPU-specific optimization, library integration, PyTorch registration, and environment compatibility. It presents a cuda-kernels agent skill that packages architecture guides, integration patterns, kernel templates, troubleshooting material, benchmarks, and Kernel Hub examples for coding agents. Claude and Codex used it to generate RMSNorm, RoPE 3D, GEGLU, and AdaLN kernels for LTX-Video in diffusers, and an RMSNorm kernel for Qwen3-8B in transformers, including CUDA source, PyTorch bindings, build configuration, and benchmark scripts. On H100 80GB HBM3, the LTX-Video RMSNorm tests averaged 1.88x speedup and the optimized pipeline with torch.compile reached 1.43x the listed baseline, while Qwen3-8B RMSNorm averaged 1.94x and reached 2.47x at 8192 tokens. The skill supports packaging kernels for precompiled distribution through the Hub, where get_kernel selects a matching binary across Python, PyTorch, and CUDA variants.
OpenEnv in Practice: Evaluating Tool-Using Agents in Real-World Environments
OpenEnv is an open-source framework from Meta and Hugging Face for evaluating AI agents against real systems rather than simulations, with stateful environments that connect to tools and APIs. Turing's production-grade Calendar Gym applies this model to calendar operations, combining access control lists, partial visibility, temporal reasoning, and multi-step workflows in isolated sessions. Agents often handled individual actions but became less reliable on longer or ambiguous tasks: success was close to 90% with explicit calendar identifiers and roughly 40% when requests used natural-language descriptions. More than half of failures involved malformed arguments or incorrect action ordering despite selecting the correct tool, while structured validation, permission, and datetime errors provided concrete recovery signals.
Transformers.js v4: Now Available on NPM!
Transformers.js v4 is now available on NPM, marking a major release after a year of development. It introduces a C++-rewritten WebGPU runtime tested across about 200 supported model architectures, enabling the same JavaScript code to run WebGPU-accelerated models in browsers, Node, Bun, Deno, and desktop applications. Specialized ONNX Runtime Contrib Operators support new export strategies for large language models, and the post reports a roughly fourfold speedup for BERT-based embedding models using MultiHeadAttention. The release also restructures the repository as a pnpm-workspaces monorepo, modularizes model definitions, moves examples to a separate repository, and switches from Webpack to esbuild, reducing build times from two seconds to 200 milliseconds and shrinking transformers.web.js by 53%. New APIs cover model asset inspection, caching, environment fetch controls, logging, and standalone tokenization, while added architectures include Mamba, MLA, and MoE models compatible with WebGPU.
Introducing SyGra Studio
SyGra 2.0.0 introduces Studio, an interactive environment for building, previewing, executing, and debugging synthetic data generation flows on a visual canvas. Users can configure connectors and models, preview source rows, reference automatically created state variables in prompts, define structured outputs, and inspect the generated YAML or JSON graph configuration. Studio streams node-level execution status, token usage, latency, cost, logs, and guardrail outcomes, while storing run history in .executions/runs/*.json and autosaving drafts. It also runs existing workflows, including a Glaive Code Assistant example with conditional revision loops, tunable dataset and batching inputs, and observable intermediate critiques; generated outputs can support training, evaluation, or annotation workflows.
Community Evals: Because we're done trusting black-box leaderboards over the community
Hugging Face is introducing Community Evals, a system for decentralized and transparent reporting of model evaluation results on the Hub. It responds to saturated benchmarks and inconsistent scores across model cards, papers, and evaluation platforms, while acknowledging that benchmark performance does not necessarily reflect real-world capabilities. Benchmark dataset repositories can register as benchmarks, define reproducible eval specifications in eval.yaml, aggregate scores from model repositories and community submissions, and display leaderboards in dataset cards. Model results are stored in .eval_results/*.yaml, while users can submit sourced scores through pull requests that remain visible as community results, with Git history and APIs supporting tracking and further aggregation. The beta feature aims to expose what was evaluated, how, when, and by whom, but it does not claim to solve benchmark saturation, test-set training, or the benchmark-reality gap.
The Future of the Global Open-Source AI Ecosystem: From DeepSeek to AI+
This third and final article in a series examines how Chinese AI organizations are shaping an open-source ecosystem after DeepSeek R1's January 2025 release. It argues that open sharing of models, papers, deployment infrastructure, and techniques has become the dominant near-term approach, with organizations ranging from Alibaba, Tencent, ByteDance, and Baidu to startups and application companies contributing at different layers. Qwen illustrates the ecosystem strategy: by mid-2025, more than 113,000 Hugging Face models used Qwen as a base, while organizations also connected models with chips, cloud platforms, toolchains, evaluation, and deployment systems. The article places this shift on infrastructure built since 2017, including the East Data, West Compute plan, and says R1 catalyzed wider use of existing compute, energy, and data capacity. It concludes that open-source models are becoming reusable, composable components in industrial workflows and localized AI systems as China moves from DeepSeek toward AI+.
Training Design for Text-to-Image Models: Lessons from Ablations
The second part of a series on training efficient text-to-image models from scratch documents training-design ablations for the PRX model. The authors establish a Flow Matching baseline (PRX-1.2B, 100K steps, 256×256, AdamW, GemmaT5, RoPE, 1M MidJourneyV6 synthetic images) and benchmark interventions against FID, CMMD, DINO-MMD, and throughput across four buckets: Representation Alignment, Training Objectives, Token Routing and Sparsification, and Data. REPA representation alignment boosts early convergence when used as a burn-in, while the Muon optimizer lowered FID from 18.20 to 15.55 and improved CMMD and DINO-MMD. Storing denoiser weights in BF16 instead of using BF16 autocast raised FID to 21.87, and token routing methods such as TREAD/SPRINT were minor at 256² but became major wins at higher resolutions. Long captions proved critical, synthetic versus real data shifted texture versus structure, and upcoming work releases the full training code alongside a 24-hour end-to-end speedrun.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.