BoundaryML/baml
48.9
Weak · 14 November 2026
1074.8k
lines of production code
Rust
with TypeScript
4
measurements over time
What this system is
Features
Add BAML TextMate grammar source
Added the BAML TextMate grammar source file (\baml.ts\) which defines syntax highlighting rules for the BAML language, including support for identifiers, literals, comments, and structural elements like classes and functions.
typescript2/pkg-grammar · high confidence
Add Go language support for the BAML CLI
Users can now invoke the BAML runtime CLI from Go applications. This change introduces a Go package wrapper that exposes the \InvokeRuntimeCli\ function, allowing Go programs to pass command-line arguments and handle exit codes directly through the BAML engine.
baml-cli · high confidence
Add LLM response parsing support for Anthropic, Google, and Vertex AI
The LLM response parser now includes dedicated modules for parsing responses from Anthropic, Google, and Vertex AI providers, in addition to the existing OpenAI and Azure support. This enables the system to correctly deserialize structured responses, including streaming chunks, tool use, and usage metadata, from these additional model providers.
engine/llm-response-parser · high confidence
Add TCP and UDP networking primitives to the standard library
The \baml.net\ module now exposes \TcpStream\, \TcpListener\, and \UdpSocket\ classes, enabling users to establish TCP connections, listen for incoming traffic, and send/receive UDP datagrams. These primitives support configurable per-call timeouts via \baml.time.Duration\ and implement the \root.io.Read\ and \root.io.Write\ interfaces for consistent I/O handling.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\net · high confidence
Add TOML parsing and serialization support with native datetime types
The standard library now includes a TOML module (\baml.toml\) that allows parsing TOML text into a structured \Table\ type and serializing tables back to JSON. This implementation introduces a dedicated \Item\ type to preserve TOML's specific data semantics, including lossless mapping of four distinct datetime kinds (offset, local datetime, local date, local time) to BAML's \baml.time\ types (\ZonedDateTime\, \PlainDateTime\, \PlainDate\, \PlainTime\), which would otherwise be flattened to strings in generic JSON handling. The module provides \Table.parse\ for text input, \Table.from\_json\ for JSON conversion (skipping nulls), and implements \baml.ToJson\ and \baml.FromJson\ interfaces for interoperability, while throwing \ParseError\ for invalid syntax or unrepresentable 64-bit integers.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\toml · high confidence
Add TypeSafe JEV client with reflection-based request planning
This change introduces a new TypeSafe JEV client implementation within the BAML standard library. It adds a \Client\ class that implements the \ai.Client\ interface, allowing users to invoke the TypeSafe JEV model via HTTP. The client leverages a new reflection system to plan requests: it traverses output types (classes, enums, unions) to generate structured questions (leaves) and options, rejecting unsupported types or recursive structures before sending the request. This enables type-safe, structured interactions with the TypeSafe JEV classifier.
_baml\_language/crates/baml\_builtins2/baml\std/typesafeai · high confidence
Add Vercel AI Gateway image model support
Introduces a new internal BAML standard library module (\images.baml\) that implements the Vercel AI Gateway image model endpoint. This addition enables users to generate and edit images via the gateway, handling request construction for prompts and media files, and parsing responses including base64 image data, usage statistics, and provider metadata.
_baml\_language/crates/baml\_builtins2/baml\_std/vercel/ns\internal · high confidence
Add YAML parsing and deserialization to the standard library
The standard library now includes a \baml.yaml\ namespace with two new functions: \parse\, which converts YAML text into JSON-compatible BAML values (rejecting non-JSON features like multi-document streams or non-string mapping keys), and \deserialize\<T\>\, which parses YAML and decodes the result into a specific type \T\ using existing \baml.FromJson\ rules. This allows users to work with YAML data directly in BAML, with errors thrown as \baml.yaml.ParseError\ for malformed input or \baml.json.DecodeError\ for type mismatches.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\yaml · high confidence
Add filesystem glob pattern scanning and matching API
Users can now compile and execute glob patterns against the filesystem using the new \baml.glob\ namespace. The \baml.glob.new\ function compiles a pattern into a \Glob\ object, which provides a \scan\ method to find matching file paths (with options for working directory, dotfiles, absolute paths, and symlink handling) and a \matches\ method for pure string pattern matching without filesystem access.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\glob · high confidence
Added Cursor AI coding rules for documentation, development setup, and workflow
New configuration files have been added to the \.cursor/rules/\ directory to guide the AI assistant's behavior. The \diataxis-docs.mdc\ rule enforces the Diátaxis documentation framework for \.mdx\ files, distinguishing between tutorials, how-to guides, reference material, and explanations. The \instructions.mdc\ rule provides specific setup and testing instructions for the BAML project, including the use of \mise\, \cargo test\, and Python integration tests. Additionally, \jj-workflow.mdc\ introduces guidelines for using the \jj\ version control system, emphasizing fine-grained commits and bookmark management.
.cursor · high confidence
Added Swift SDK build and code-generation scripts
Introduced three new shell scripts in the Swift SDK directory to support the new Swift bridge: \build-xcframework.sh\ compiles the Rust bridge into an XCFramework for macOS and iOS (supporting both host-only development and full multi-arch release builds with bitcode stripping), \generate-header.sh\ uses cbindgen to produce the C header bindings required by the Swift package, and \generate-protos.sh\ regenerates the Swift protobuf client code from the bridge wire format definitions. These scripts enable developers to build and integrate the Swift SDK locally without manual intervention.
_baml\language/sdks/swift/scripts · high confidence
Added WebSocket client support for real-time providers
The BAML standard library now includes a \WebSocket\ class and \connect\ function, enabling users to establish real-time connections with custom LLM providers. This new capability allows sending text or binary frames, blocking to receive incoming messages, and managing connection lifecycles with close codes and reasons, all exposed through the \ns\_ws\ module.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\ws · high confidence
Added architecture dependency graph and generation tooling
The \baml\_language/architecture\ directory now includes a generated SVG diagram visualizing the workspace's crate dependencies, grouped by namespace (e.g., \baml\, \bex\, \sdkgen\). A new \generate.sh\ script and \README.md\ document the process for regenerating this graph using the \cargo-stow\ tool, which displays local crates, external dependencies, and cross-namespace edges.
_baml\language/architecture · high confidence
Added language server hot-reload tool for development
A new \language-server-hot-reload\ binary has been added to the engine tools, enabling developers to automatically restart the BAML CLI language server when source files change. This tool monitors the binary directory for modifications and replays stdin input to the newly spawned process, streamlining the development and debugging workflow for the language server.
engine/tools · high confidence
Added sandbox server and trace upload stubs
The engine/sandbox module now includes a basic HTTP server (web\_server.rs) that listens on port 4000 and returns a greeting, alongside stub implementations for trace data upload (upload-traces-main.rs) and tracing context setup (main.rs). These files are currently largely commented out or empty, serving as scaffolding for future tracing and server functionality rather than active features.
engine/sandbox · high confidence
Automated Rust code generation for BAML standard library builtins
The \baml\_builtins2\codegen\ crate now automatically generates the Rust trait hierarchies, dispatch tables, and type wrappers for the BAML standard library. By parsing \.baml\ source files, it extracts native builtins and produces the \BamlClass\\ and \BamlNamespace\\ traits for VM functions, as well as the \IoNamespace\\ traits and \SysOp\ enum for IO operations. It also generates the \ErrorClass\ and \PanicClass\ enums from their respective namespaces, ensuring that the Rust implementation stays in sync with the BAML stdlib definitions.
_baml\_language/crates/baml\_builtins2\codegen · high confidence
Automated on-call handoff and release notification system
The on-call workflow now includes automated Slack notifications for weekly handoffs and release outcomes. A new parser validates and canonicalizes the on-call schedule file, while a notification module composes structured Slack messages that detail the outgoing and incoming on-callers, their responsibilities (preparing the next release, reviewing the changelog, thanking contributors), and upcoming shifts. Additionally, a release notifier tool queries GitHub Actions to detect job failures and posts detailed failure reports to Slack, tagging the current on-call engineer to investigate.
baml-tools · high confidence
BAML language support for CodeMirror with syntax highlighting and autocomplete
The BAML language package for CodeMirror has been updated to provide comprehensive syntax highlighting, code folding, and autocomplete support. The Lezer grammar now defines specific tags for BAML constructs such as classes, enums, functions, and attributes, enabling distinct visual styling for keywords, types, and comments. Additionally, the language support includes snippet completions for common BAML patterns like class and function declarations, improving the developer experience when writing BAML files.
typescript/packages/codemirror-lang-baml · high confidence
Claude Code CLI integration internals
Added internal BAML functions to support the Claude Code CLI provider, including logic to assemble conversation transcripts into a text format, define a JSON schema envelope for handling both final results and tool calls, and implement a protocol string that instructs the LLM on how to request tools via the outcome field. The entry also includes utilities for parsing the CLI's JSONL output stream and logging events. Also in this area: JSON API renamed and unified for direct value handling.
_baml\_language/crates/baml\_builtins2/baml\_std/claude\_code/ns\internal · high confidence
Concurrency primitives: spawn, await, and future combinators
The standard library now includes a concurrency model based on \spawn\ and \await\. Users can create concurrent tasks using \spawn\, which returns a \Future\ handle. This handle supports state inspection (\is\_settled\, \is\_cancelled\, \state\) and cancellation (\cancel\). The library provides combinators for managing multiple futures: \all\ waits for all futures to succeed (cancelling the rest on the first error), \all\_settled\ waits for all futures to complete regardless of outcome, and \race\ completes as soon as the first future settles. Configuration for spawned tasks is handled via \TaskGroup\ (for concurrency limiting and shared cancellation) and \CancelToken\ (for cooperative cancellation).
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\future · high confidence
First-class C\# SDK generation and runtime support
This change introduces the initial C\# SDK implementation, providing first-class code generation and runtime capabilities for the BAML language. It includes a complete test suite covering basic function calls, dynamic value handling (including enums, records, unions, and generics), error and cancellation management, host callables (closures and callbacks), and media types. The SDK generates C\# projects that can be built and tested, ensuring parity with other supported languages.
_baml\_language/sdk\_tests/crates/csharp, baml\_language/sdks/csharp/sdkgen\csharp · high confidence
Formatter AST implementation for BAML language constructs
The BAML formatter now includes a complete AST layer in \baml\_fmt/src/ast\ to parse and pretty-print BAML source code. This implementation introduces strong-typed nodes for all top-level declarations (functions, classes, interfaces, enums, clients, tests, and generators), expressions (including \if let\, \match\, \catch\, \spawn\, and optional chaining), statements (such as \let\, \while let\, and \for\), and patterns (supporting destructuring and type narrowing). It also defines specific handling for attributes, tokens, and interface items, enabling the formatter to correctly structure and output complex BAML language features.
_baml\_language/crates/baml\fmt · high confidence
Go SDK introduces native runtime integration and BAML type system
The Go SDK now includes a standalone runtime that initializes via \Initialize\ and manages native library loading, version checking, and shutdown. It adds comprehensive support for BAML classes (including generic type arguments) and a first-class \BAMLType\ system for constructing and reflecting on types (primitives, classes, enums, unions) with schema metadata. The SDK also implements the BEP-81 invocation ABI, enabling the invocation of BAML closures across SDKs and providing robust error reporting for spawned work.
github.com/boundaryml/baml-go · high confidence
Go client code generation overhaul with streaming, multimodal, and type builder support
The Go language generator has been completely rewritten to support advanced runtime features. Generated code now includes full streaming capabilities (via \CallFunctionStream\ and typed channels), multimodal input support (Image, Audio, PDF, Video), and a dynamic TypeBuilder for runtime schema modification. The generator also introduces \build\_request\ and \parse\ function variants, configurable call options (clients, tags, environment variables), and robust type handling for unions, enums, and dynamic classes with proper JSON marshaling and validation.
engine/generators/languages/go · high confidence
IDE support for code lenses, inlay hints, and completions
The BAML IDE now provides interactive editor features: code lenses allow users to run functions and tests directly from the Playground via click actions; inline inlay hints display inferred types for variable bindings and parameter names for function calls to aid readability; and a comprehensive completion engine offers context-aware suggestions for values, types, members, and declaration skeletons, including snippet support for new items.
_baml\_language/crates/baml\ide/src · high confidence
Initial C++ SDK code generation engine
The C++ SDK generator has been implemented, producing a single-header layout with namespace routing, free functions for callables (supporting required and optional arguments via per-function options structs), and classes/enums with generated codec specializations. The emitter handles transparent and recursive type aliases (using baml::Box for cycle-breaking), order-canonical multi-member unions, and typed error unions via BamlThrown. It also includes a robust typed naming system that resolves collisions and preserves BAML wire identities separately from C++ identifiers.
_baml\_language/sdks/cpp/sdkgen\cpp · high confidence
Initial LSP protocol dispatch layer for the BAML language server
The BAML language server now exposes a complete Language Server Protocol (LSP) interface, enabling IDE integration for features such as diagnostics, hover information, completions, go-to-definition, renaming, document symbols, and semantic tokens. This change introduces the core dispatch infrastructure in the \baml\_lsp\ crate, including request and notification handlers, event processing for background tasks like diagnostics collection, and protocol-specific type conversions for IDE data. It also supports multi-root workspaces, incremental document synchronization, and stdlib source serving through read-only editor documents.
_baml\_language/crates/baml\lsp/src/dispatch · high confidence
Initial Ruby (Sorbet) code generator support
The BAML engine now generates a Ruby client library with Sorbet type checking. This includes a synchronous client (\BamlSyncClient\) and a streaming client (\BamlStreamClient\) that support passing runtime options such as collectors, environment variables, and tags. The generator produces type-safe classes and enums, a \TypeBuilder\ for dynamic schema construction, and dedicated modules for \Types\ and \StreamTypes\ to handle standard and streaming return values respectively.
engine/generators/languages/ruby · high confidence
Initial Rust SDK and CLI scaffolding for BAML v0
This change introduces the initial structure for the BAML v0 Rust SDK and CLI within the \languages/rust\ directory. It adds the \baml-cli\ binary entry point, \baml-sys\ for dynamic FFI library loading, \baml-macros\ for derive macros (\BamlEncode\, \BamlDecode\), and the core \baml\ runtime crate. The entry also includes comprehensive integration tests for value encoding/decoding, collector functionality, and FFI interactions, alongside documentation and license files for the new Rust components.
languages · high confidence
Initial Rust SDK bridge and verification workflow
This change introduces the \baml\_bridge\ crate, which serves as the runtime bridge for generated Rust SDKs, handling engine bootstrapping, value conversion via the \BamlValue\ trait, and exposing BAML's typed \throws\ contracts as \Result\<T, baml\_bridge::Error\<E\>\>\. It includes integration tests that verify class, enum, map, and generic type conversions against a live engine, as well as a verification workflow (\verify/\) that exercises both synchronous and asynchronous entry points to ensure the engine loads correctly and the version handshake passes. Also in this area: Rust and TypeScript SDKs now properly seal telemetry and finish in-flight work at shutdown.
_baml\_language/sdks/rust/bridge\rust/tests · high confidence
Initial Rust SDK bridge implementation
The Rust SDK bridge is now available, providing the core infrastructure for the Rust client to communicate with the BAML engine. This includes the C ABI definitions for engine interaction, a bidirectional value-conversion system for type-safe data exchange, and support for invoking BAML closures (functions) from Rust code. The implementation handles asynchronous and synchronous function calls, result decoding, and error mapping, establishing the foundational runtime for Rust-based BAML applications.
_baml\_language/sdks/rust/bridge\rust · high confidence
Initial infrastructure for pkg.boundaryml.com static site hosting
This change introduces the AWS CDK stack that provisions the S3 bucket and IAM role required to host the pkg.boundaryml.com static site. The stack creates a public-read S3 bucket configured for static website hosting and an IAM role that allows GitHub Actions (from the BoundaryML/baml repository) to assume permissions via OIDC for publishing releases from the canary branch or immutable release tags.
_tools/pkg\_boundaryml\com · high confidence
Integration test suite initialization and configuration
The integration test suite has been initialized with a new project structure, including a README detailing the testing architecture and prerequisites for TypeScript, Python, and Ruby. A VS Code settings file has been added to enable the playground proxy for local development. The test definitions are organized under \baml\_src\, featuring client configurations for providers like OpenAI, Azure, and Gemini, along with specific test cases for features such as media handling, abort handlers, aliases, and constraints.
integ-tests · high confidence
Internal Google Cloud authentication and Vertex AI client implementation
Added internal BAML standard library functions for Google Cloud authentication (\gcp\_access\_token\, \gcp\_project\_id\, \gcp\_quota\_project\_id\) and a complete typed implementation of the Vertex AI Gemini client (\vertex.baml\), including request/response classes, URL construction, and credential resolution logic.
_baml\_language/crates/baml\_builtins2/baml\_std/google/ns\internal · high confidence
Introduce BAML C++ SDK with std-library naming conventions
The BAML C++ SDK is now available as a self-contained, header-only library generated alongside your BAML project. It adopts the C++ standard library's snake\_case naming convention for types, functions, and constants (enforced via clang-tidy), while retaining Google-style formatting. The SDK embeds the BAML bytecode and a vendored protobuf-lite runtime (pinned to v31.1) to ensure ABI stability and support offline builds. It provides a typed boundary layer for data encoding/decoding, support for arbitrary-precision integers (\bigint\), and handles runtime loading via a structured resolution order (programmatic path, environment variable, executable-adjacent, or shared cache) with stable error codes for failures.
_baml\language/sdks/cpp · high confidence
Introduce BAML Enhancement Proposal (BEP) feedback application
A new standalone web application for managing BAML Enhancement Proposals (BEPs) has been added to the \typescript2\ workspace. Built with Next.js 15 and Convex, it provides a centralized platform for proposal discussion, featuring threaded comments, version history, and AI-assisted analysis of version changes using the BAML runtime. The application includes a full feedback lifecycle with status tracking, decision logging, and export capabilities. Also in this area: 5 commits (0 fixes) modifying typescript2; 4 commits (1 fix) modifying typescript2/app-beps; Standard library JSON functions renamed and simplified; Developer docs workflow decouples snippet checks and adds a type-system quiz app; Updated documentation for TypeScript SDK generation and vision examples.
typescript2 · medium confidence · unverified
Introduce BAML IntelliJ extension with syntax highlighting, LSP, and playground
The JetBrains directory now contains the source code for the BAML IntelliJ extension, providing syntax highlighting for BAML source files, language server functionality (including xref navigation and jump-to-definition) via the LSP4IJ framework, and an interactive BAML playground tool window powered by JCEF. The project is scaffolded using the IntelliJ Platform Gradle Plugin template, built with Gradle and Kotlin, and includes configuration for Qodana static analysis and GitHub Actions for automated testing and deployment.
jetbrains · high confidence
Introduce BAML compiler2 AST layer with BEP-042 cleanup finalizers and LLM companion functions
The \baml\_compiler2\_ast\ crate now provides the concrete AST and CST-to-AST lowering for the BAML language, replacing the previous structure with owned, spanned data structures. This change introduces support for the BEP-042 \cleanup\ magic method, which acts as a run-once finalizer for class instances by injecting a guard around the method body. It also adds automatic generation of LLM companion functions (\@spec\, \@render\_prompt\, \@build\_request\, \@parse\) for functions marked with LLM metadata, enabling provider-neutral request previews and prompt rendering. The new AST layer includes comprehensive type expression handling (including \Media\, \Uint8Array\, and \void\ types), field attribute disambiguation, and docstring extraction, establishing the structural foundation for the compiler2 pipeline.
_baml\_language/crates/baml\_compiler2\ast · high confidence
Introduce BAML compiler2 database and diagnostics infrastructure
The \baml\_db\ crate now provides the core database layer for the new compiler2 pipeline, replacing the previous implementation. It introduces \ProjectDatabase\, a Salsa-backed store that manages source roots, file contents, and dependency graphs. This change adds comprehensive project diagnostics collection (\check\), which aggregates parse, HIR, and type-inference errors into a unified report. It also includes project resolution logic to locate \baml.toml\ manifests and \baml\_src\ directories, file discovery utilities that respect \.gitignore\ patterns, and a typed manifest parser for \baml.toml\. Additionally, it implements the program compilation driver, which emits packages and links them into a final bytecode program, supporting caching via \PackageCache\ and pre-compiled stdlib prefixes for faster startup.
_baml\_language/crates/baml\db · high confidence
Introduce BAML v0 VS Code and Cursor extension
This change adds the initial BAML v0 VS Code and Cursor extension, providing syntax highlighting for .baml files, an integrated LLM Playground webview for testing prompts, and code lens navigation from generated client code back to BAML function definitions. It also includes keyword auto-completion for BAML attributes, project telemetry reporting via PostHog, and a status bar indicator for diagnostics.
typescript/apps/vscode-ext · high confidence
Introduce BEX VM types and runtime infrastructure
This change introduces the \bex\_vm\_types\ crate, establishing the foundational type system and runtime structures for the new BEX virtual machine. It defines the bytecode instruction set and data structures (including jump tables and perfect hash tables for efficient dispatch), implements a total order for floating-point comparisons that ensures reflexivity and consistent NaN handling, and provides a type-safe indexing system (\Indexable\) to prevent cross-pool access errors. The crate also adds a per-container spin-lock (\LazyBiasedMutex\) for safe concurrent mutation of arrays and maps, raw pointer-based heap references (\HeapPtr\) for stable object access, and a comprehensive set of VM-level error and panic types (\VmPanic\, \VmBamlError\) that map to user-visible exception classes. Additionally, it includes a build script to generate system operation and error enums from builtin definitions, and a content-addressed identity hash for program source files.
_baml\_language/crates/bex\_vm\types · high confidence
Introduce BexStr, a V8-inspired immutable string type with O(1) cloning
The \bex\_str\ crate now provides \BexStr\, a new immutable string type designed for performance and memory efficiency. It supports O(1) cloning by using reference-counted sharing for heap-allocated strings and zero-copy slicing. The type optimizes small strings (≤54 bytes) by storing them inline, avoiding heap allocations entirely. It also features deferred concatenation (rope-like behavior) that flattens only when necessary, and includes comprehensive benchmarks and tests for codepoint indexing, hashing, and memory footprint tracking.
_baml\_language/crates/bex\str · high confidence
Introduce C\# SDK bridge with native runtime integration
This change adds the initial C\# SDK bridge implementation, providing the managed runtime layer that connects .NET applications to the native BAML engine. It introduces a comprehensive CFFI (C Foreign Function Interface) layer for safe memory management and interop, including \BamlSafeHandle\ for native handle ownership, \NativeApi\ for invoking runtime functions, and \HostCallDispatcher\ for executing host callbacks. The bridge also includes \NativeLibraryResolver\ for locating the native library, \NativeMedia\ for handling media types, and a full set of exception types (\BamlExecutionException\, \BamlInitializationException\, etc.) to surface errors from the runtime to C\# consumers.
_baml\_language/sdks/csharp/bridge\csharp · high confidence
Introduce C\# SDK build and release tooling
This change adds a suite of repository-only tools to the C\# SDK build pipeline to support first-class generation and release hygiene. The \Baml.BytecodeCarrierEmitter\ tool embeds canonical compiler bytecode into a generated C\# source file with SHA-256 fingerprinting and lazy initialization, enabling verification gates before the production generator is fully implemented. The \Baml.NuGetNormalizer\ rewrites unsigned NuGet packages into a deterministic, reproducible ZIP/OPC format with stable timestamps and permissions, and includes a comparison mode to verify that registry-signed packages match the verified unsigned payload. The \Baml.UnionGenerator\ produces the C\# source for typed union structs (up to 32 cases), while the \Baml.Union.LayoutProbe\ benchmarks the memory and performance characteristics of these unions. Finally, the \pack-product.sh\ script orchestrates the release process by validating native assets, inspecting binary exports for security and platform compliance, and assembling the final NuGet package.
_baml\_language/sdks/csharp/bridge\csharp/tools · high confidence
Introduce Go SDK runtime and generated SDK support
The Go SDK (\baml\_language/sdks/go/baml\_go\) is now available, providing the runtime package that generated Go SDKs use for wire encoding and native runtime calls. It introduces a dynamic loading mechanism for the shared CFFI runtime artifact, including version verification, SHA-256 cache validation, and programmatic configuration via \RuntimeConfig\. The SDK supports encoding and decoding complex types such as lists, maps, enums, and generic classes, and enables invoking BAML closures and \FunctionSpec\ capabilities (including streaming event callbacks) from Go.
_baml\_language/sdks/go/baml\go · high confidence
Introduce Java/JVM bridge for BAML runtime integration
Added a new JNI-based bridge (\bridge\_java\) that enables Java applications to invoke BAML functions synchronously. This component links the \bex\_engine\ in-process via \bridge\_cffi\, allowing Java code to initialize the runtime from bytecode and execute BAML functions by passing encoded protobuf envelopes, mirroring the architecture of the existing Python and Node.js bridges.
_baml\_language/sdks/java/bridge\java · high confidence
Introduce Node.js (TypeScript) SDK bridge
The TypeScript SDK bridge is now available, providing a native Node.js addon (built with napi-rs) that mirrors the existing Python bridge. This enables BAML runtime initialization, synchronous and asynchronous function invocation, host instrumentation, and media handling directly from Node.js environments.
_baml\_language/sdks/typescript/bridge\typescript · high confidence
Introduce Prompt Fiddle web application with project embedding and interactive tours
The fiddle-web-app now provides a full Next.js-based playground interface for BAML projects. Users can now generate and share embeddable links via a new Embed dialog, which allows configuring the embedded view to show or hide the file tree, playground, and specific files, and supports Link, Iframe, and React integration methods. The application includes a guided product tour for new users and a post-test-run tour to explain results. Additionally, the app features a file tree viewer for managing project files, a top navbar with project renaming and sharing capabilities, and integrates PostHog for pageview tracking.
typescript/apps/fiddle-web-app · high confidence
Introduce Ruby FFI bindings for BAML runtime
This change adds the Ruby FFI layer (\engine/language\_client\_ruby/ext/ruby\_ffi\), exposing the BAML runtime to Ruby applications. It introduces Ruby classes for managing the runtime (\Baml::Ffi::BamlRuntime\), dynamic type definitions (\Baml::Ffi::TypeBuilder\), and client configuration (\Baml::Ffi::ClientRegistry\). It also provides bindings for handling function execution results (\Baml::Ffi::FunctionResult\), streaming responses (\Baml::Ffi::FunctionResultStream\), and a comprehensive logging collector (\Baml::Ffi::Collector\). Additionally, it adds support for media input types, exposing Ruby classes for \Image\, \Audio\, \Pdf\, and \Video\ to allow passing these assets to BAML functions.
_engine/language\_client\_ruby/ext/ruby\ffi · high confidence
Introduce Ruby bridge with native runtime integration
The Ruby SDK now includes a new bridge layer that connects to the BAML native runtime via FFI. This addition registers the Ruby language with the BAML V1 bridge (ABI version 4), enabling the loading of compiled BAML programs from byte blobs and managing the runtime lifecycle. The implementation includes specific error handling for configuration issues, library loading failures, version mismatches, and fork safety, ensuring that the native state is correctly claimed by the process and that incompatible programs are rejected.
_baml\_language/sdks/ruby/bridge\ruby · high confidence
Introduce Ruby language client with streaming, dynamic types, and media support
Adds the initial Ruby language client library, providing core infrastructure for interacting with the Baml engine. This includes support for streaming responses via \BamlStream\, dynamic type conversion with \TypeConverter\, and structured output handling through \Checked\ and \DynamicStruct\ classes. The client also exposes bindings for handling images and audio, enabling Ruby applications to consume rich media outputs from Baml functions.
_engine/language\_client\ruby · high confidence
Introduce Swift SDK bridge with native type support and host callbacks
The Swift SDK now includes a new BamlBridge module that provides the foundational runtime bridge for Swift applications. This adds support for arbitrary-precision integers via the \BamlBigInt\ type, enables recursive data structures through copy-on-write \BamlIndirect\ wrappers, and implements a complete type system for encoding and decoding BAML values (including unions, handles, and media). Additionally, it introduces a mechanism for host callables, allowing BAML functions to invoke Swift closures asynchronously with proper error handling and resource management.
_baml\language/sdks/swift/Sources/BamlBridge · high confidence
Introduce Swift SDK with code generation and runtime bridge
This change adds the initial Swift SDK, providing a Rust-based code generator (\sdkgen\_swift\) that translates BAML symbols into Swift source files. The generator emits Swift structs for classes, enums, and type aliases, handling generic parameters and recursive types via boxing. It includes a diagnostics system that generates a \\_BamlSkipped.swift\ manifest with \\#warning\ directives for any symbols that could not be translated, ensuring the generated package always compiles. The SDK also includes a Swift runtime bridge (\BamlBridge\) and an invocation facade (\invocation\_facade.swift\) that exposes \BamlOptions\, \CancelToken\, and \Invocation\ capabilities to Swift consumers.
_baml\_language/sdks/java/sdkgen\_java, baml\_language/sdks/swift/rust/sdkgen\swift · high confidence
Introduce VFS path abstraction with Windows-specific normalization
Added a new \baml\_path\ crate that defines a \VfsPathBuf\ type for handling absolute, normalized paths within BAML's virtual file system, ensuring logical paths always start with \/\ and contain no empty, \.\, or \..\ components. This change introduces platform-specific path handling: on non-Windows systems, native paths are converted to VFS paths by stripping prefixes and normalizing components, while on Windows, the implementation now explicitly supports drive letters (e.g., \C:\) and UNC paths (e.g., \\\server\\share\), mapping them to stable VFS representations like \/C:/...\ and \/server/share/...\. This ensures that native Windows paths round-trip correctly through the VFS domain without losing share roots or drive information, addressing previous issues with path and URI handling on Windows.
_baml\_language/crates/baml\path · high confidence
Introduce Web and Cloudflare Workers runtimes for the BAML TypeScript SDK
The TypeScript SDK now supports execution in browser and Cloudflare Workers environments via a new \@boundaryml/baml-bridge-web\ package. This release adds a Rust/WASM bridge that enables core BAML capabilities—such as staging runtimes, invoking functions (both sync and async), and handling media—directly in the browser. It includes specific build scripts and source transformations to ensure compatibility with WebAssembly and the Workers runtime, along with comprehensive test coverage for error handling, media management, and invocation contexts. Also in this area: BAML Language SDKs updated to version 0.23.0; Explicit SDK shutdown and telemetry finalization in TypeScript bridges.
(repo-wide) · high confidence
Introduce Zed editor extension for BAML
Added a new Zed editor extension that integrates the BAML language server. The extension automatically downloads the matching \baml-cli\ binary from GitHub releases based on the current version and platform, and configures the language server with specific initialization options such as enabling code generation on save and forwarding runtime updates to the webview.
engine/zed · high confidence
Introduce \`baml pack\` host binary for executing packaged BAML programs
This change adds the runtime host (\baml\_pack\_host\) that executes binaries produced by the new \baml pack\ command. The host extracts a versioned \PackEnvelope\ from an embedded OS-native section, initializes the BAML engine with the embedded program and telemetry, and dispatches execution based on the pack mode: single-target binaries act as one-shot CLIs where flags bind to function parameters, while multi-subcommand binaries allow selecting specific functions via subcommands. It handles argument parsing, error reporting, and exit codes, ensuring packaged BAML applications run as standalone executables.
_baml\_language/crates/baml\_pack\host · high confidence
Introduce \`baml run\` and \`baml pack\` entry points with auto-CLI and structured argument handling
The \baml\_exec\ crate now provides the shared execution logic for the new \baml run\ and \baml pack\ commands. Users can invoke BAML functions directly from the command line using an auto-derived CLI interface that accepts primitive types (strings, integers, floats, booleans, enums, and nulls) as flags (e.g., \--name value\). For complex types like classes, lists, or maps, arguments must be passed via the \--json-args\ flag, which supports inline JSON, file paths (\@file\), or stdin (\-\). Packaged binaries embed a dispatch envelope that allows them to run these targets with the same argument parsing and output formatting (Debug or JSON) as the development CLI. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Standard library JSON functions renamed and simplified.
_baml\_language/crates/baml\exec · low confidence · unverified
Introduce atb2 feedback-to-issue triage pipeline
A new automated feedback pipeline has been added in tools/atb2 that ingests user reports from PostHog and Slack, triages them into GitHub issues with reproducible examples, estimates difficulty, and automatically implements fixes via an AI agent in a sandboxed worktree. The pipeline handles the full lifecycle: creating issues, assigning subsystem owners, running design and fix passes, opening draft pull requests, and monitoring PRs until they merge or fail, with all state persisted in Supabase and audit trails maintained for each run.
tools · high confidence
Introduce baml-cli with Boundary Cloud integration and new subcommands
The \baml-cli\ tool is now available, providing a unified command-line interface for BAML projects. It includes commands for initializing projects (\init\), generating code (\generate\), checking for errors (\check\), running tests (\test\), and formatting source files (\fmt\). A new \deploy\ command enables publishing projects to Boundary Cloud, supported by a new \auth\ module that handles login and token management via PropelAuth. The CLI also features a new Language Server (\lsp\) for IDE integration, an \optimize\ command for prompt optimization, and a \dev\/\serve\ mode for local development. Internal commands like \auth\, \login\, \deploy\, \fmt\, \dumphir\, \dumpbytecode\, and \repl\ are hidden by default to reduce clutter, while feature flags (\beta\, \display\_all\_warnings\) allow users to control experimental behavior.
engine/cli · high confidence
Introduce bex\_project as the reusable compile-and-run runtime for BAML programs
The new \bex\_project\ crate provides the core runtime API for compiling and executing BAML projects. It exposes the \Bex\ trait for invoking functions and managing invocations, along with a \new\ constructor that compiles in-memory source files and initializes the engine. The crate embeds a precompiled standard library artifact (generated at build time via \build.rs\) to ensure the stdlib interfaces remain consistent with the compiler version, and it centralizes runtime error handling and cancellation logic for use by SDK bridges and the LSP server.
_baml\_language/crates/bex\project · high confidence
Introduce binary size gating tool with baseline management and CI integration
The \tools\_size\_gate\ crate adds a new CLI for monitoring and enforcing binary size limits. It supports measuring \cdylib\, \bin\, and \baml pack\ artifacts across platforms, comparing them against per-platform baselines, and enforcing absolute and delta-based size policies. The tool includes a \bake\ command to automatically refresh baselines and ceilings from CI reports, ensuring the gate adapts to legitimate size changes without manual intervention.
_baml\_language/crates/tools\_size\gate · high confidence
Introduce cargo-stow for Rust workspace linting and structure validation
Added a new Rust workspace tool, cargo-stow, designed to enforce governance in monorepos. It validates flat crate layouts, enforces naming conventions (e.g., \\<namespace\>\_\<word\>\), ensures dependencies use workspace-level declarations, and restricts dependency usage via configurable rules. The tool also provides auto-fix capabilities for sorting dependencies and formatting TOML, as well as SVG dependency graph visualization.
_baml\_language/crates/tools\stow · high confidence
Introduce centralized release management and platform contract for BAML toolchain and SDKs
This change introduces the \baml\_release\ crate, which establishes the authoritative logic for resolving the BAML home directory, fetching versioned release artifacts, and validating manifest schemas. It defines a structured platform contract (\platforms.json\) that serves as the single source of truth for build matrices across the toolchain, Python, Node.js, Java, C\#, and CFFI bridges, ensuring that supported targets and artifact configurations are consistent. Users benefit from a more robust and standardized installation and update process for the BAML CLI and its language-specific SDKs, with improved validation of downloaded artifacts and clearer support for multi-platform distributions.
_baml\_language/crates/baml\release · high confidence
Introduce dedicated release pipeline scripts for SDK mirrors, hygiene, and version management
The scripts directory now includes a suite of new Python utilities that formalize the BAML release process. \assemble-go-sdk-mirror\ and \assemble-swift-sdk-mirror\ generate self-contained source trees for the Go and Swift package managers, with the Swift script specifically stamping release asset URLs and checksums into the Package manifest. \baml-bridge-cffi-hygiene\ scans native binaries to reject build-machine paths and credential-shaped strings, hardening shipping artifacts. \baml-csharp-release-contract\ validates the C\# projection against a platform contract, ensuring correct RIDs and native assets. \baml-language-version\ and \baml-wrapper-version\ manage canonical SemVer surfaces across registries (npm, PyPI, NuGet, etc.) and the wrapper crate respectively. \baml-release-manifests\ and \baml-release-platforms\ generate toolchain/wrapper JSON manifests and validate wrapper artifact sets against the platform contract. Finally, \baml\_nightly\_select.py\ validates canary CI coverage to safely select nightly release sources.
scripts · high confidence
Introduce external type system for FFI boundaries
The \bex\_external\_types\ crate now provides the foundational types for crossing the boundary between the BEX engine and external host languages (Python, JavaScript, C FFI). This includes \BexExternalValue\, a self-contained value tree for FFI conversion that supports union types with metadata, and \Handle\, an opaque, thread-safe reference to heap objects that ensures safe memory management via RAII. Additionally, \host\_return.rs\ introduces strict, schema-free validation to ensure that values returned from host-callable functions match their declared return types, preventing type corruption at the engine boundary.
_baml\_language/crates/bex\_external\types · high confidence
Introduce local BTEL reader for inspecting recordings without a query backend
A new \btel\_reader\ crate enables users to read and inspect BAML telemetry recordings directly from the local filesystem without requiring a SQL database or cloud backend. The reader discovers completed recording files, validates their integrity, and lazily decodes captured values and context from the Content-Addressable Storage (CAS) blobs. It provides structured navigation of function arguments and outputs, supports semantic value comparison, and resolves execution timing and source locations using only the data embedded in the recordings themselves. Also in this area: Fixes telemetry upload stalls by replacing bounded snapshot pools with unbounded ones and adding overage handling.
_baml\_language/crates/btel\reader · high confidence
Introduce local SQL querying for BAML telemetry recordings
Users can now run SQL queries directly against BAML telemetry recordings via the \baml query\ CLI command. This new capability indexes BTEL recording files into a local SQLite database and exposes them through a set of predefined tables (processes, profiler, spans, etc.) with support for navigating captured BAML values, filtering by context, and exporting results in table, JSON, or JSONL formats.
_baml\_language/crates/baml\_query\btel/src · high confidence
Introduce modular BAML editor workbench with remote playground support
The \typescript2/pkg-editor\ package now provides a structured, modular editor workbench that separates the shared Monaco UI from the backend transport layer. Users can now run the BAML playground over remote WebSocket connections (e.g., via \baml-cli playground\) instead of being limited to in-browser WASM workers, enabling the editor to function over SSH tunnels and remote servers. This change introduces a pluggable \EditorBackend\ interface, a dedicated \ExecutionPanelPane\ for the playground UI, and a \remote-backend\ implementation that connects to external LSP and runtime endpoints. The workbench also includes a new 'Monospace Dark' theme and improved handling of media files and workspace paths.
typescript2/pkg-editor · high confidence
Introduce multi-root workspace support and LSP diagnostics
The BAML language server now supports multi-root workspaces, allowing users to open and edit multiple BAML projects within a single IDE session. This change introduces a new project discovery mechanism that identifies project roots via \baml.toml\ manifests or \baml\_src/\ markers, and implements the Language Server Protocol (LSP) to provide real-time diagnostics. Users will now see compiler errors and warnings directly in their editor, with support for standard LSP features like position encoding negotiation (UTF-8/UTF-16) and read-only stdlib document viewing.
_baml\_language/crates/baml\lsp/src · high confidence
Introduce new AI standard library packages and clients
The AI standard library now includes dedicated packages for the core AI runtime (\ai\), the Claude Code CLI harness (\claude\_code\), the Vercel AI Gateway image client (\vercel\), and a new TypeSafe JEV client (\typesafeai\). These packages provide the foundational types, runner interfaces, and provider-specific client implementations that replace the previous \sys\_llm\ system, enabling first-class support for structured output, streaming, tool use, and prompt caching across these providers.
_baml\_language/crates/baml\_builtins2/baml\std/ai · high confidence
Introduce shared ctypes bridge crate for cross-language value conversion
The new \baml\_language/crates/bridge\_ctypes\ crate provides the shared infrastructure for converting values across the C FFI and WASM boundaries. It includes a build script that generates Rust (prost) and Python (protoc) clients from the \baml\_bridge\ protobuf definitions, a global handle table for managing opaque values crossing the boundary, and comprehensive encoding/decoding logic for host values, types, and tracebacks. This centralizes the serialization logic previously scattered across language-specific bridges, ensuring consistent handling of primitives, complex types, and media assets for all SDK consumers.
_baml\_language/crates/bridge\ctypes · high confidence
Introduce standard I/O functions and Read/Write interfaces
The standard library now includes basic console I/O capabilities with \input\ for reading from stdin (returning an error on failure rather than panicking) and \print\, \println\, \eprint\, and \eprintln\ for writing to stdout and stderr (panicking on host unavailability). Additionally, new \Read\ and \Write\ interfaces are available to abstract byte-level streaming, providing methods like \bytes\, \text\, \write\_some\, and \flush\ to handle data ingestion and output in a manner consistent with Rust and JavaScript stream models.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\io · high confidence
Introduce streaming CSV standard library with typed readers and writers
The BAML standard library now includes a new \baml.csv\ module providing streaming CSV readers and writers. Users can parse CSV data into typed records using \rows\<T\>\, \decode\<T\>\, and \read\<T\>\, leveraging the same column-matching rules as the JSON library. The module supports configurable options for delimiters, quoting, error handling (such as skipping malformed records), and encoding, while also offering a writer with options for quote styles, headers, and CSV-injection sanitization. Errors are structured with positional diagnostics (line, record, field) and distinct kinds for robust handling. Also in this area: JSON API renamed and unified for direct value handling.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\csv · high confidence
Introduce structured test infrastructure and compiler benchmarks
The baml\_tests crate now provides a comprehensive, tiered test infrastructure for the BAML compiler, including a build script that auto-generates test modules from project directories and embeds a pre-compiled standard library prefix for consistent test execution. It introduces a new benchmarking suite (compiler\_benchmark) with incremental, scale, and realistic workload categories, alongside a CodSpeed integration that automatically generates wall-time benchmarks from the speedtest workload corpus. The setup includes standardized snapshot handling via .gitattributes and insta.yaml, and a README documenting how to add, run, and maintain compiler and runtime tests.
_baml\_language/crates/baml\tests · high confidence
Introduce sys\_types crate for system operations and SSE parsing
The new \sys\_types\ crate centralizes the type definitions and infrastructure for the BEX runtime's external I/O operations. It provides the \SysOp\ trait and associated types (such as \BexExternalValue\, \CallId\, and \OpError\) that allow the engine to dispatch file system, network, and shell operations. Additionally, it includes an incremental Server-Sent Events (SSE) parser (\SseParser\) to handle streaming data, and uses build scripts to generate typed I/O structs from the BAML standard library, ensuring type safety for external function calls.
_baml\_language/crates/sys\types · high confidence
Introduce the Prompt Fiddle playground with in-browser WASM runtime and Monaco editor
The Prompt Fiddle app is now available as a standalone Next.js application, providing an interactive environment for editing and running BAML programs directly in the browser. This release adds a full client-side architecture including a Monaco editor with BAML syntax highlighting, a dedicated Web Worker hosting the BAML WASM runtime for execution and LSP features, and a virtual filesystem that supports both text and media files. Users can now run BAML code locally without external dependencies, with state persistence via localStorage and a reset option to restore default files.
typescript2/app-promptfiddle · high confidence
Introduce type-system quiz tool for learning BAML type rules
Added a new interactive quiz tool under \baml\_language/tools/type\_quiz\ that teaches the BAML type system by asking users to predict compiler behavior. The tool generates cases from the type system specification and verifies them against the real compiler to ensure accuracy. It includes a structured engine for generating questions, a bank of test cases covering subtyping, variance, and coherence, and a conformance suite to prevent drift from the spec. The tool also tracks compiler divergences from the specification and provides a web SDK for the user interface. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
_baml\_language/tools/type\_quiz, baml\_language/tools/type\_quiz/ns\harness · low confidence · unverified
Introduce unified content block types for AI turns
The \ai.content\ namespace now defines a standardized vocabulary for AI interaction data, replacing provider-specific envelopes with a unified set of classes: \Text\, \Reasoning\, \ToolUse\, and \Media\. Users can now construct and process turns using these normalized blocks, with helper functions like \blocks()\ to automatically convert raw strings and media values into the appropriate block types, and \text()\ to generate readable string projections from mixed content. This change ensures that all turns (user, model, or tool results) share a consistent structure, simplifying how content is handled across different LLM providers.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\content · high confidence
Introduce versioned C FFI bridge API (V1) for host-language integration
The \bridge\_cffi\ crate now provides a stable, versioned C ABI (Revision 4) that allows host languages to dynamically load the BAML runtime. This API exposes a function table (\BamlApiV1\) containing entry points for runtime initialization, function invocation, media handling, and host-value dispatch. It enforces strict memory ownership rules for byte buffers and handles, supports concurrent callback delivery, and includes compatibility checks to ensure the host bridge and runtime are built against matching ABI revisions.
_baml\_language/crates/bridge\cffi · high confidence
Introduces BAML Language Server extension with playground and protocol compatibility
The VS Code extension now includes a new Language Server Protocol (LSP) implementation that manages a single server instance per workspace window, resolving previous issues with multi-root workspaces and stdlib document handling. It introduces protocol versioning (LSP protocol 1, Playground protocol 2) to ensure client-server compatibility and provides a built-in playground UI. The playground is served via a webview panel that maps to a specific server port, injects the necessary WebSocket URL for communication, and rewrites asset URLs to work within VS Code's security context. The extension also adds status bar indicators for server state and commands to open the playground for specific projects.
typescript2/app-vscode-ext · high confidence
Introduces BEX Heap with generational garbage collection and lock-free allocation
The \bex\_heap\ crate now provides the runtime's shared memory management, featuring a semi-space copying garbage collector with four generations (Gen0, Gen1, Gen2, and inactive) and a card table for tracking cross-generation references. Allocation is handled via Thread-Local Allocation Buffers (TLABs) for lock-free fast paths, backed by a \ChunkedVec\ to ensure stable object pointers during concurrent growth. The heap exposes a safe accessor API for external code to read heap objects via permits, manages function identity and telemetry metadata, and coordinates collection through epoch-based safepoints to ensure all VMs are yielded before garbage collection runs.
_baml\_language/crates/bex\heap · high confidence
Introduces browser-based WASM runtime for BAML analysis and playground
Adds the \bridge\_wasm\ crate, enabling BAML to run in the browser via WebAssembly. This includes a WASM-specific implementation of the standard library (HTTP, environment variables, I/O, file system, time, and random number generation) that delegates platform operations to JavaScript callbacks. The crate provides a Language Server Protocol (LSP) wire layer for browser-based code analysis and a playground engine that builds and manages BAML execution contexts synchronously on the main thread. It also implements in-memory run history and live value caching to replace disk-based storage, allowing users to run and debug BAML programs directly in their browser tabs.
_baml\_language/crates/bridge\wasm · high confidence
Introduces centralized telemetry configuration and policy settings
The \baml\_language/crates/btel\_settings\ crate now provides a unified source for telemetry configuration, defaults, and tuning constants. It defines recording policies (including \RecordingLevel\ and \InitialFailurePolicy\), artifact-specific settings for packed binaries (such as embedded ingestion credentials and destination overrides), and privacy boundaries for network spans (allowlisting specific HTTP headers and query parameters). The module also establishes encoding format versions, local file delivery paths, clock calibration tolerances, and performance tuning constants for the processor, publisher, and transport layers. Also in this area: 1 commit (1 fix) fixing baml\_language/crates/bex\_vm, baml\_language/crates/btel\_settings; Improved telemetry resilience and privacy controls.
_baml\_language/crates/btel\settings · medium confidence · unverified
Introduces core compiler infrastructure and language primitives
The \baml\_base\ crate now provides the foundational types and logic for the BAML compiler, including source file management via Salsa, file/span tracking, and qualified name resolution. It adds support for BEP-049 backtick string literals with auto-dedenting and escape handling, as well as parsing for hex, octal, and binary integer and bigint literals. The crate also defines the standard library package structure (e.g., \baml\, \ai\, \reflect\), schema attribute specifications, and validation for LLM client options.
_baml\_language/crates/baml\base · high confidence
Introduces lazy environment variable references to prevent credential leakage and support offline rendering
The \env\ namespace now provides a \Ref\ class and \env.NAME\ sugar that creates a lazy reference to an environment variable rather than reading its value immediately. This ensures that credentials are never stored inside constructed values (such as client definitions), preventing accidental leakage through printing, serialization, or journaling. Additionally, a new \get\_or\_panic\_lenient\ function allows generated client constructors to tolerate missing environment variables during offline spec prompt rendering, while direct network calls still enforce strict presence of required credentials.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\env · high confidence
Introduces lazy iterator adapters and a new \`Iterable\`/\`Iterator\` interface
The standard library now includes a new \baml.iter\ namespace featuring an \Iterable\ interface and an \Iterator\ interface with lazy adapters such as \map\, \filter\, \filter\_map\, \flat\_map\, \step\_by\, and \chain\. These adapters process elements on-demand rather than eagerly, allowing for efficient chaining of operations. The \Iterator\ uses a \Done\ sentinel type to distinguish between valid null elements and the end of the sequence, and error types propagate through the chain via union types.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\iter · high confidence
Introduces shared generic type-variable inference and union normalization
A new \baml\_type\_runtime\ crate has been added to centralize pure \Ty\<N\>\-walking primitives for generic-call inference and union normalization. This change removes the previously hand-maintained type inference logic from the runtime engine, replacing it with a shared algorithm that both the compiler and the runtime engine can use. For users, this ensures consistent type inference behavior across compile-time and runtime boundaries, particularly for generic functions and union types, while laying the groundwork for more robust variance-aware type checking.
_baml\_language/crates/baml\_type\runtime · high confidence
Introduces streaming API with strict termination contracts
Adds the \stream.baml\ module defining the core streaming types (\TurnStream\, \Stream\, \Event\) and the \StreamingClient\ interface, enabling BAML functions to return incremental text deltas. This change introduces a strict termination contract where streams can require an explicit end-of-turn marker from the provider (via \require\_terminal\); if the connection closes without this marker, a \NetworkFailure\ is thrown instead of silently reporting a truncated turn as complete. It also includes support for token-count timeouts and wire telemetry recording within the stream lifecycle.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\stream · high confidence
Introduces structured RPC types for AST, authentication, and runtime tracing
The \engine/baml-rpc\ module now defines the core data structures and API contracts used by the BAML runtime and Studio. This includes a new type-safe ID system (\baml-ids\) for function calls, events, and projects, and a comprehensive AST representation (\ast/\) that models functions, types, and source code with stable identifiers. Authentication is formalized with \auth/\ types for API keys, permissions (e.g., \TracesWrite\, \BamlDeploy\), and environment management. Runtime interactions are standardized via \runtime\_api/\, which specifies the schema for trace events (\BackendTraceEvent\), function call errors, BAML value serialization, and S3 upload metadata for blobs and traces. These types serve as the shared interface between the engine, the backend, and the UI.
engine/baml-rpc · high confidence
Introduces structured run history and value artifact storage
The \bex\_events\ crate now includes a new \history\ module that manages a dedicated \history-v1\ directory under \.baml/\ for storing run lifecycle events (start, completion) and structured log bodies. This system uses a \BoundaryWriter\ with segment rotation policies to write data into per-thread \.bamlvalue\ files, separating this host history from profiling data. It also introduces a \BlobStore\ for managing value artifacts with SHA-256 integrity verification and a \LiveValueCache\ for in-memory value caching with LRU eviction. Additionally, the crate adds ID generation utilities for processes, engines, and threads, along with protobuf-based encoding for value records.
_baml\_language/crates/bex\events · high confidence
Introduces typed wire models for the Anthropic Messages API
The Anthropic client now uses explicit BAML classes to define the structure of requests and responses for the Messages API, replacing previous untyped or loosely typed approaches. This change introduces specific types for message content blocks (text, media, tool use, tool results), tool parameters, and usage statistics, ensuring that every field sent to or received from the API is strictly typed. It also includes internal logic to handle local request rejections and serialization helpers to drop null values, aligning the client's data model with the Anthropic API specification.
_baml\_language/crates/baml\_builtins2/baml\_std/anthropic/ns\internal · high confidence
Introduction of custom BAML logging library
The \baml-log\ crate has been introduced to replace the previous logging implementation, providing a dedicated logging interface for BAML. This new library supports both standard text and JSON output formats, with configuration controlled via BAML-specific environment variables (\BAML\_LOG\, \BAML\_LOG\_JSON\, \BAML\_LOG\_STYLE\). It offers dynamic runtime configuration for log levels and color modes, and includes structured event logging capabilities via new macros like \event!\ and \elog!\ for serializing payloads as JSON objects.
engine/baml-lib/baml-log · high confidence
Introduction of feature flags and IR hashing infrastructure
The engine now supports configurable feature flags, including \beta\ (to enable beta features and suppress experimental warnings) and \display\_all\_warnings\ (to show all warnings in CLI output), allowing users to control the visibility and behavior of experimental capabilities. Additionally, a new Intermediate Representation (IR) hashing system has been implemented to generate stable signatures for BAML classes, enums, functions, clients, and type aliases, which facilitates efficient change detection and caching within the engine.
engine/baml-lib/baml-core · high confidence
Introduction of the BAML Virtual Machine (VM) compiler and runtime
The BAML compiler has been re-architected to introduce a new Virtual Machine (VM) execution model. This change replaces the previous interpretation path with a two-stage compilation process: source code is lowered into a High-level Intermediate Representation (HIR) and then compiled into VM bytecode. This new architecture includes a dedicated bytecode interpreter, a type-checked intermediate representation (THIR), and a static control-flow visualizer (Viz) to support runtime debugging and streaming. The compiler now natively supports advanced language features such as \@watch\ notifications, class methods, and built-in types like \baml.HttpRequest\ and \baml.HttpMethod\.
engine/baml-compiler · high confidence
Introduction of the BEX VM bytecode interpreter
The \bex\_vm\ crate introduces a new stack-based bytecode interpreter for the BAML language, replacing the previous execution model. This change adds a new runtime engine that executes compiled bytecode via a dispatch loop, managing a call stack, evaluation stack, and a shared heap with Thread-Local Allocation Buffins (TLABs) for object allocation. The implementation includes support for negative array indexing, call specialization for performance optimization, and detailed debugging utilities for bytecode inspection. It also integrates with the build system to generate Rust bindings for native builtins from standard library packages.
_baml\_language/crates/bex\vm · high confidence
Introduction of the BEX VM bytecode interpreter
The \bex\_vm\ crate introduces a new stack-based bytecode interpreter for the BAML language, replacing the previous execution model. This change adds a new runtime engine that executes compiled bytecode via a dispatch loop, managing a call stack, evaluation stack, and a shared heap with Thread-Local Allocation Buffins (TLABs) for object allocation. The implementation includes support for negative array indexing, call specialization for performance optimization, and detailed debugging utilities for bytecode inspection. It also integrates with the build system to generate Rust bindings for native builtins from standard library packages.
_baml\_language/crates/btel\records · high confidence
Java SDK bridge harness and runtime foundations
The Java SDK bridge is now available, providing the core runtime components needed to invoke BAML functions from Java applications. This release introduces the \BamlFfi\ entry point for synchronous and asynchronous calls, along with supporting types for handling BAML types (\BamlType\), function specifications (\BamlFunctionSpec\), prompts (\BamlPrompt\), and streaming results (\BamlStream\). It also includes infrastructure for managing object lifecycles via \BamlHandle\, encoding/decoding logic for complex types like unions (\Union2\–\Union10\), and utilities for generic type binding (\BamlTypes\).
baml-bridge · high confidence
Java SDK bridge introduces structured error handling and type-safe callable dispatch
The Java SDK bridge now provides structured error types—BamlError for thrown values, BamlPanic for non-exit panics, and BamlCancelledError for async cancellations—each carrying decoded values and pre-rendered BAML stack traces. It also introduces a type registry for mapping BAML types to generated Java classes and a callable dispatch system that supports type-directed decoding and encoding for host-provided functions, ensuring that arguments and return values are handled according to their declared BAML types rather than raw wire formats.
_baml\_language/sdks/java/baml\bridge · high confidence
Kotlin-first SDK bridge with coroutine, streaming, and union ergonomics
The \baml-bridge-kotlin\ module now provides idiomatic Kotlin support for the BAML runtime. Users can leverage \bamlCall\ for coroutine-friendly execution of Java futures, \asFlow\ and \awaitFinal\ for consuming engine streams as Kotlin \Flow\s, and \fold\/\armNOrNull\ extension functions for exhaustive, type-safe handling of union types (Union2–Union10). These additions are accompanied by unit tests for the call context, stream flow, and union folding logic.
_baml\language/sdks/java/baml-bridge-kotlin · high confidence
Native BAML LLM provider clients with dynamic selection and reliability wrappers
This change introduces the native Rust-based LLM provider clients for BAML, replacing the previous system LLM implementation. It adds a \clients.baml\ module that enables dynamic client selection at call time via a \Selector\ type (supporting explicit clients, provider/model shorthand strings, or environment variable references). It also implements reliability features including configurable retry logic with exponential backoff, fallback mechanisms, and specific handling for provider-reported errors (e.g., rate limits, timeouts) across AWS Bedrock and Anthropic providers.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\clients · high confidence
Native JSON type and serialization functions
The standard library now includes a native \json\ type representing untyped JSON values (null, bool, int, float, string, arrays, and maps), along with functions to parse JSON strings into this type (\parse\), serialize \json\ values back to strings (\stringify\, \stringify\_pretty\), and convert arbitrary BAML values to/from JSON (\to\_json\, \from\, \from\_string\, \to\). Error handling is standardized with specific exception classes: \ParseError\ for invalid JSON syntax, \DecodeError\ for type mismatches during decoding, and \SerializationError\ for values that cannot be represented in JSON. The \from\_string\<T\>\ function performs structural decoding into a target type \T\, while \to\<T\>\ (via \from\_json\) honors \baml.FromJson\ overrides. Also in this area: LLM output parsing now respects custom type shapes via FromLlmOutput; JSON API renamed and unified for direct value handling.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\json · high confidence
Native local BTEL telemetry recording and delivery
The \btel\_file\ crate now provides native local delivery for BAML telemetry, writing completed recording files and content-addressable storage (CAS) blobs directly to disk. This change introduces a file-based backend that handles sequence-based recording files, manages a shared CAS for immutable blobs, and exposes a reader to validate and inspect local recording directories, enabling offline analysis of telemetry data without requiring cloud delivery.
_baml\_language/crates/btel\file · high confidence
Native support for MCP servers as BAML tools
Users can now integrate Model Context Protocol (MCP) servers directly into BAML workflows. The new \mcp.baml\ library provides a \Connection\ class that spawns an MCP server process, performs the JSON-RPC 2.0 handshake, and exposes the server's tool catalog as standard BAML tools. This allows any MCP-compatible server to be used as a tool within BAML agents or direct calls, with tool execution handled by the BAML runner and visible via \on\_event\.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\mcp · high confidence
Native system operations provider with host callable support and HTTP server
The \sys\_native\ crate now provides the native Tokio-based implementation for system operations, introducing a new \NativeSysOps\ provider that handles file, environment, time, and shell operations. This update adds the ability to invoke host-language functions (Python, Node, Go) directly from BAML via the \baml.host.call\_host\_value\ sysop, including argument encoding, in-flight call tracking, and contract validation. It also introduces a built-in HTTP/HTTPS server (\baml.http.Server\) with WebSocket support, allowing BAML applications to serve HTTP endpoints and handle WebSocket upgrades natively.
_baml\_language/crates/sys\native · high confidence
New API keys management dialog and file tree component
The playground now includes a dedicated API keys dialog that allows users to add, edit, import from .env files, and manage environment variables with auto-save and visibility toggles, alongside a new file tree viewer component for navigating project files.
typescript/packages/playground-common · high confidence
New AST module with visualization and language feature support
The \engine/baml-lib/ast\ crate has been introduced to provide the core Abstract Syntax Tree representation for BAML source code, including nodes for control flow (if, while, for loops), assertions, and method calls. This module also adds built-in visualization capabilities, generating Mermaid flowcharts to display header-based scopes and execution structure, and exposes a debug utility to render the entire AST as a visual diagram.
engine/baml-lib/ast · high confidence
New AWS Bedrock client with streaming, caching, and timeout support
A new \BedrockClient\ is now available in the AWS standard library, enabling calls to the Amazon Bedrock Converse API. This client supports streaming LLM responses, prompt caching via \${cache()}\ for system prompts and tools, and configurable timeouts. It also allows passing extra request fields, headers, and query parameters, with credentials resolved at request time using the standard AWS provider chain.
_baml\_language/crates/baml\_builtins2/baml\std/aws · high confidence
New Anthropic and Google LLM client packages in the standard library
The standard library now includes dedicated \anthropic\ and \google\ packages that provide first-class, typed clients for interacting with these providers. The \anthropic\ package introduces a \Client\ class for the Messages API, supporting features like extended thinking (\ThinkingConfig\), tool choice strategies (\ToolChoice\), and configurable timeouts. The \google\ package exposes two clients: \GeminiClient\ for the standard Gemini Developer API (with typed safety settings and generation config) and \VertexClient\ for Google Cloud Vertex AI (supporting OAuth2, service account credentials, and express API keys). Both clients handle credential resolution at request time to avoid construction-time panics and implement the standard \ai.Client\ and \ai.stream.StreamingClient\ interfaces.
_baml\_language/crates/baml\_builtins2/baml\std/google · high confidence
New BAML CLI commands and agent skill installation
The BAML CLI now includes several new subcommands to improve project management and agent integration. Users can install the bundled BAML agent skill using \baml agent install\, which places the skill in \.agents/skills\ or \.claude/skills\ within the project root. Authentication is managed via \baml auth\ (login, whoami, logout) using WorkOS device-code flow, and feedback can be submitted via \baml feedback\. Project validation is now possible with \baml check\, which reports compiler errors and warnings without executing code. Additionally, \baml clean\ allows users to remove segmented local profiler data, and \baml describe\ provides an agent-friendly way to explore project symbols, namespaces, and the standard library with search and JSON export capabilities. Also in this area: 1 commit (0 fixes) modifying (repo-wide); LLM output parsing now respects custom type shapes via FromLlmOutput; Unified compilation pipeline and JSON API simplification; Option to exclude HTTP request/response bodies from telemetry; Hide stdlib internals in describe listings and refine generation output; and 1 more.
_baml\_language/crates/baml\cli/src · low confidence · unverified
New BAML Standard Library package with core types and interfaces
The BAML standard library is now a distinct, implicitly available package (\baml.toml\) that provides the foundational types and interfaces for the language. This includes the core value types (\int\, \float\, \bigint\, \string\, \bool\, \null\, \uint8array\) with their specific behaviors (e.g., \bigint\ for arbitrary precision, \float\ with total ordering for NaN), the \Array\<T\>\ collection with mutation and iteration methods, and the \baml.ToString\, \baml.ToJson\, and \baml.FromJson\ interfaces for opt-in serialization and string conversion. It also introduces the \baml.ops.Compare\ and \baml.ops.Sortable\ interfaces to enable generic sorting and comparison logic across these types.
_baml\_language/crates/baml\_builtins2/baml\std/baml · high confidence
New BAML benchmark suite for compiler, runtime, and profiling
The repository now includes a comprehensive benchmark suite in \baml\_tests/benches\ to measure BAML performance across three dimensions. \runtime\_benchmark.rs\ measures pure VM execution speed using workloads from the speedtest corpus, while \compiler\_benchmark.rs\ measures the cost of compiling BAML source into bytecode (including an empty-project baseline). \package\_compile\_benchmark.rs\ specifically benchmarks the cold-cost and dispatch parity of the public \reflect.Package.compile\ API. Additionally, \profiling\_overhead.rs\ quantifies the performance cost of the profiling subsystem by comparing execution times with profiling enabled, suppressed, and logging-only modes. A new \cache\_profile.rs\ bench provides hardware performance counter data (cycles, IPC, cache misses) for specific workloads on macOS.
_baml\_language/crates/baml\tests/benches · high confidence
New BCS API crate for cloud authentication, telemetry, and build-time credential provisioning
This change introduces the \baml\_language/crates/bcs\_api\ library, which provides the native client implementation for Boundary Cloud Services (BCS). It adds a shared, file-based login cache (\\~/.baml/login/cache/\) for Boundary device login and API key authentication, with endpoint-scoped credential storage. The crate implements the cloud wire contracts (protobuf \cloud.proto\) for telemetry uploads, including a new \logical\_bytes\_approx\_v1\ field in CAS objects for reporting approximate logical bytes. It also adds build-time provisioning of public ingestion credentials via the \/v1/build-tokens\ endpoint, allowing packed binaries and bridges to embed telemetry credentials. The library handles authorization renewal, query cancellation, and diagnostic reporting for cloud operations, serving as the shared HTTP client layer for the CLI, bridges, and packed programs. Also in this area: 2 commits (1 fix) modifying baml\_language/crates/baml\_builtins2, baml\_language/crates/bcs\_api, baml\_language/crates/bex\_engine.
_baml\_language/crates/bcs\api · medium confidence · unverified
New BTEL ingestion engine for telemetry recordings
The BAML query system now uses a new ingestion pipeline to process BTEL telemetry recordings into a local SQLite database. This change introduces bulk indexing for call paths and profiler data, allowing the CLI and playground to query detailed performance metrics such as function invocation counts, durations, and error rates. It also adds support for storing and resolving Content-Addressable Storage (CAS) context snapshots, enabling users to inspect the specific context state present at the start of function calls and network spans.
_baml\_language/crates/baml\_query\btel/src/ingest · high confidence
New BTEL snapshot capture and CAS blob infrastructure
The \baml\_language/crates/btel\_snapshot\ crate introduces a new system for capturing and serializing telemetry data into Content-Addressable Storage (CAS) blobs. This includes an arena-based memory model for efficient storage reuse, a builder for constructing snapshot graphs with strict size and depth limits, and a new CAS blob format (v4) using XXH3-128 hashing for identity verification. The implementation supports capturing context metadata, host values, and complex object graphs (including cycles and shared references) while ensuring data integrity through verified round-trip encoding and decoding.
_baml\_language/crates/btel\snapshot · high confidence
New CLI commands for project initialization, validation, and development
The \baml-cli\ now includes dedicated commands for initializing new projects (\init\), validating BAML source files without generating code (\check\), and starting a development server with hot-reloading (\dev\). The \init\ command automatically detects the user's editor (VS Code or Cursor) and installs the corresponding extension, while \check\ reports validation errors and warnings. The \dev\ command watches the \baml\_src\ directory for changes and automatically regenerates clients and reloads the runtime, streamlining the local development workflow.
engine/baml-runtime · high confidence
New GC policy experiment harness for reproducible profiling
Added a new tooling suite in \baml\_language/tools/gc\_policy\ consisting of \build.py\, \run.py\, and \summarize.py\ to build, execute, and analyze paired garbage-collection experiments. This harness allows developers to compare baseline and candidate GC implementations by running a defined matrix of workloads (such as scalar, churn, and retained object scenarios) with randomized ordering to reduce drift bias. It enforces build provenance via SHA-256 verification against build manifests, captures detailed per-cycle profiling data (including phase timings like root scan and fixup), and generates comprehensive Markdown and JSON reports comparing execution speed, memory usage, and pause times between variants.
_baml\_language/tools/gc\policy · high confidence
New Go SDK code generator with native formatting and type projection
A new Go SDK emitter has been added to the \sdkgen\_go\ crate, introducing a greenfield code generation pipeline for Go. This implementation projects BAML types into idiomatic Go structures, including support for primitive functions, classes, enums, type aliases, nullable wrappers, and functional options for defaulted arguments. The generator now ensures output quality by automatically formatting all generated Go files using the \gofmt\ tool, handling errors and large payloads robustly. It also manages package structure by mapping BAML packages to distinct Go packages and handles name collisions and visibility rules.
_baml\_language/sdks/go/sdkgen\go · high confidence
New HTTP client, server, and WebSocket primitives
The standard library now includes a comprehensive HTTP module (\baml.http\) providing \fetch\ and \send\ for making outgoing requests with optional timeouts, and \Server\ for binding and serving incoming HTTP/HTTPS traffic with configurable limits, TLS support, and HTTP/1 or HTTP/2. It also introduces Server-Sent Events (SSE) support via \fetch\_sse\ and \SseStream\, as well as WebSocket handling through the \websocket\ parameter in \Server.serve\ and the \WsAccept\ type, allowing BAML applications to act as full-featured network endpoints.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\http · high confidence
New Java SDK with Gradle plugin and Kotlin ergonomics
Users can now generate a typed BAML Java SDK directly within their Gradle builds using the new \com.boundaryml.baml\ plugin, which handles code generation, incremental caching, and automatic injection of the \baml-bridge\ runtime and platform-specific native libraries. The release also introduces \baml-bridge-kotlin\, a library providing Kotlin-idiomatic features such as coroutine bridges for streams and cancellation-aware call contexts, which is automatically included when the Kotlin JVM plugin is applied. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
_baml\language/sdks/java/gradle-plugin · low confidence · unverified
New Rust SDK with automatic type derivation and dynamic library loading
The Rust SDK now provides \\#\[derive(BamlEncode)\]\ and \\#\[derive(BamlDecode)\]\ macros in \baml-macros\ to automatically serialize and deserialize Rust structs and enums to and from the BAML runtime format, supporting features like dynamic fields and literal variants. To support this, the \baml-sys\ crate introduces a new runtime dynamic library loading mechanism that resolves the native library from explicit paths, environment variables, or by auto-downloading it from GitHub releases with SHA-256 checksum verification.
languages/rust/baml · high confidence
New SAP module for schema-aligned parsing in custom LLM providers
A new \sap\ module has been added to the standard library, exposing the Schema-Aligned Parsing (SAP) logic used by BAML's built-in LLM path to BAML-authored providers. This module provides \parse\ and \parse\_type\ functions, allowing users to coerce raw LLM text output into typed results using the same internal coercion mechanisms, thereby enabling consistent parsing behavior for custom provider implementations. Also in this area: LLM output parsing now respects custom type shapes via FromLlmOutput; JSON API renamed and unified for direct value handling.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\sap · high confidence
New SQL-based profiling query engine for BAML execution profiles
A new \baml\_query\_profiles\ crate has been added to provide a SQL interface over BAML execution profiles stored in the \profiles-v1\ format. This feature allows users to query execution data (such as threads, calls, contexts, and health metrics) using standard SQL via DataFusion, with a local file-based store that supports deterministic snapshots and CAS-backed value resolution. The implementation includes a decoder for the engine's trace codec, a fold cache for efficient per-execution profile loading, and relation providers that map store data to SQL tables, enabling detailed analysis of BAML program runs without relying on the playground UI.
_baml\_language/crates/bex\engine · high confidence
New TypeScript SDK codegen engine with Node and Web runtime support
The TypeScript SDK generator has been rewritten to produce a fully typed \baml\_sdk/\ directory structure (using \index.ts\ files instead of declaration stubs) that supports both Node.js (\@boundaryml/baml-bridge\) and Web/Worker (\@boundaryml/baml-bridge-web\) runtimes. The new emitter generates real TypeScript classes, enums, and type aliases, while routing functions to \defineFunction\/\defineInstanceFunction\ bindings with sync/async variants. It also introduces a lazy type-map system (\\_typemap.ts\) to resolve cross-leaf type references and re-exports five runtime-owned stdlib types (media, stream, prompt, reflect) from the configured bridge package.
_baml\_language/sdks/typescript/sdkgen\_typescript\shared · high confidence
New TypeScript SDK with AbortController, media types, and client registry
The TypeScript language client has been implemented as a new native module (via napi-rs), introducing several key capabilities. Users can now cancel in-flight LLM requests using the standard JavaScript AbortController API, which maps to Rust cancellation tokens. The SDK exposes new media types for handling images, audio, PDFs, and videos via \BamlImage\, \BamlAudio\, \BamlPdf\, and \BamlVideo\ classes, supporting both URL and base64 inputs. A \ClientRegistry\ type allows users to programmatically register and configure LLM clients (e.g., specifying providers and retry policies) before runtime initialization. Additionally, the module includes a \Collector\ for tracing/logs, error handling that maps internal BAML errors to specific JavaScript error types, and a CLI invocation wrapper.
_engine/language\_client\typescript · high confidence
New TypeScript client code generation with streaming, abort, and React hooks
The TypeScript generator now produces a complete client library including async and sync clients, request builders, and parsers, along with a new set of React hooks and server actions for seamless integration. Users can now leverage native AbortSignal support to cancel in-flight requests, access intermediate thinking tokens via the onTick callback, and specify LLM clients through the client option. The generated code also includes browser-compatible media types (Image, Audio, Pdf, Video) and a robust state management system for handling streaming responses in React applications.
engine/generators/languages/typescript · high confidence
New TypeScript serialization layer for BAML function arguments and results
The \typescript2/pkg-proto\ package now provides the core TypeScript utilities for encoding and decoding BAML function calls and results via protobuf. This includes \encodeCallArgs\ and \encodeRunArgs\ for serializing JavaScript values (including \bigint\, media, and prompt AST) into the wire format, and \decodeCallResult\ for deserializing responses back into native TypeScript types like \BamlJsMedia\ and \BamlJsPromptAst\. The package also exports the necessary type definitions and a test suite to ensure round-trip fidelity.
typescript2/pkg-proto · high confidence
New UDF engine for evaluating Jinja-based cost calculations
The \engine/boundary-udf\ module now provides a dedicated Rust-based engine for parsing YAML configuration files and evaluating Jinja expressions to compute LLM usage costs. This change introduces a new configuration schema (\UDFConfig\) that supports global and function-scoped constants, match conditions, and return expressions. The engine handles complex logic such as matching provider-specific pricing (e.g., OpenAI, Anthropic, Gemini) via override trees, compiling Jinja templates with a custom \date\_between\ filter, and managing undefined variable access by zeroing missing values or reporting them as missing. It also includes a path-trie data structure to efficiently track and zero out nested undefined fields during evaluation.
engine/boundary-udf · high confidence
New VS Code webview shell and comprehensive test coverage for the BAML playground
This change introduces the \app-vscode-webview\ package, providing a dedicated React shell for the BAML playground inside VS Code. It includes the root \App\ component, which manages WebSocket connections and project state, and a lazily loaded \RemoteEditorView\ that integrates the Monaco workbench via a remote LSP backend. The \ExecutionPanel\ and \FunctionSidebar\ components are now fully covered by new unit tests (including gating, strict-mode lifecycle, and interaction tests), ensuring the run workflow and sidebar navigation behave correctly in the webview environment.
typescript2/pkg-playground · high confidence
New \`baml.crypto\` standard library with authenticated encryption and hashing
The \baml.crypto\ namespace is now available in the standard library, providing a set of cryptographic primitives for secure data handling. Users can now perform authenticated encryption using \Aes256GcmSiv\ and \Aes128GcmSiv\ (nonce-misuse-resistant), \ChaCha20Poly1305\, and \XChaCha20Poly1305\ (stream ciphers with 96-bit and 192-bit nonces respectively). Additionally, incremental hashing is supported via \Sha256\. These classes are defined in new \.baml\ files under \baml\_std/baml/ns\_crypto\, implementing standard interfaces like \Aead\ and \Hasher\, and include specific error handling for decryption failures.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\crypto · high confidence
New \`baml.time\` standard library with nanosecond-precision date and time types
The \baml.time\ module now provides a comprehensive set of date and time types modeled after the TC39 Temporal proposal, including \Instant\ for absolute timestamps, \Duration\ for exact timespans, and wall-clock types (\PlainDate\, \PlainTime\, \PlainDateTime\, \ZonedDateTime\) for civil calendar operations. These types support high-precision arithmetic (nanosecond resolution using \bigint\), robust parsing of ISO 8601 and RFC 3339 formats, and explicit handling of timezone conversions and daylight saving time ambiguities via \Disambiguation\ strategies. The library also introduces \TimeZoneOffset\ for fixed offsets and integrates with the new \baml.ToJson\ and \baml.FromJson\ interfaces for serialization.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\time · high confidence
New assert standard library with tolerant float and type-checking assertions
The \assert\ standard library is now available, providing built-in functions for validating test conditions. It includes \is\_true\, \not\_null\, \equal\, and \contains\ for basic checks, alongside a new \approx\_equal\ function for comparing floating-point values within a specified tolerance, and \is\_type\ for verifying and narrowing value types at runtime. This library is implicitly available to all packages and depends on the \baml\ and \reflect\ standard libraries.
_baml\_language/crates/baml\_builtins2/baml\std/assert · high confidence
New build and release scripts for the TypeScript Web bridge
Added a set of Node.js scripts to the TypeScript Web bridge SDK to automate the build, packaging, and release process for WebAssembly targets. The \build-wasm-release.mjs\ script compiles the core bridge for both browser and Cloudflare Workers (workerd) environments. \prepare-workerd-package.mjs\ adapts the generated artifacts for the Workers runtime by patching protobuf dependencies and configuring the WASM loader, while \prepare-wasm-package.mjs\ cleans up build artifacts that would otherwise be excluded from the npm package. \sync-node-runtime.mjs\ creates a Node.js-compatible shared runtime by stripping Node-specific APIs (like \Buffer\ and \process\) and bundling protocol definitions for the browser. Finally, \sync-wasm-declarations.mjs\ ensures type consistency between the browser and workerd WASM outputs by comparing and synchronizing TypeScript declaration files.
_baml\_language/sdks/typescript/bridge\_typescript\web/scripts · high confidence
New built-in AI tooling library for defining and managing function calls
The \tools.baml\ file introduces a new standard library module for AI integrations, providing the \Tool\, \Toolbox\, \tool()\, and \raw\_tool()\ constructs. This allows users to define functions as AI tools with automatic schema generation from BAML signatures, handle raw JSON schemas for external sources like MCP servers, and manage tool collections with duplicate-name validation. The implementation includes error handling modes (\Report\ vs \Raise\) and internal logic for type-coercing model-provided arguments into typed handler parameters.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\tools · high confidence
New built-in logging functions accept any BAML value
The standard library now includes \info\, \debug\, \warn\, and \error\ functions that accept an \unknown\ type, allowing users to log any BAML value—including maps, strings, numbers, booleans, lists, class instances, enum variants, and null—directly as the log event's data. This change enables more flexible and structured debugging and observability without requiring manual serialization or type conversion before logging.
_baml\_language/crates/baml\_builtins2/baml\std/log · high confidence
New common package for shared types and schemas
A new \typescript/packages/common\ package has been introduced to centralize shared TypeScript definitions. This includes interfaces and types for the parser database (functions, classes, enums, and implementations), schemas for client event logs and LLM events using Zod, and test-related structures such as test status enums and result interfaces. Additionally, a patch for \vscode-inline-wasm-as-base64\ has been added to force WASM URLs to be inlined as base64 regardless of the SSR or Vitest environment.
patches, typescript/packages/common · high confidence
New compiler2 bytecode emitter with stackification optimizations
The \baml\_compiler2\_emit\ crate introduces a new code generation pipeline that compiles MIR2 to VM bytecode using a stackification strategy. This approach optimizes performance by inlining virtual locals and carrying values on the stack (phi-like, return-phi, call-result immediate, and aggregate operands) instead of storing them to stack slots, reducing memory pressure and improving execution speed. The emitter includes sophisticated analysis for switch statement dispatch (jump tables, perfect hashing, binary search), copy propagation, constant propagation, and dead code elimination, alongside a verifier to ensure MIR and analysis invariants are maintained.
_baml\_language/crates/baml\_compiler2\emit · high confidence
New control-flow visualization graph built directly from the compiler2 AST
The \baml\_compiler2\_visualization\ crate now generates control-flow graphs directly from the compiler2 Abstract Syntax Tree (AST) instead of the intermediate VIR representation. This change ensures that the visualization graph remains valid and renderable even when the source code contains parse or type errors, because the AST builder uses \Expr::Missing\ and \Stmt::Missing\ sentinels for error recovery rather than failing. The module exposes functions to build these graphs from AST expression bodies and includes a three-pass flattening pipeline to prune implicit nodes, hoist branch arms with labeled fan-out edges, and inline branch-arm containers for a cleaner visual representation.
_baml\_language/crates/baml\_compiler2\visualization · high confidence
New development and CI tooling scripts for the BAML language workspace
This change introduces a suite of new scripts in the \baml\_language/scripts\ directory to support development workflows and quality gates. The \bench-compare\ script enables performance profiling and side-by-side comparison of VM metrics (instructions, cycles, IPC) across branches. The \lsp-multi-root-smoke.py\ script provides live integration testing for the LSP server's multi-root workspace support over stdio. Additional tooling includes \find\_uncovered\_rs.py\ to detect Rust files outside the Cargo workspace, \fmt\_cpp.sh\ for C++ code formatting, \hawk\ for dead-public API analysis, \validate\_markdown.py\ for markdown file governance, and \speedtest\ for running speed tests.
_baml\language/scripts · high confidence
New directory writer utility for code generation
A new \dir\_writer\ utility has been added to the engine to manage the creation and organization of generated output directories. This component introduces \GeneratorArgs\ to handle configuration for various code generators (including Python and TypeScript clients) and defines a \LanguageFeatures\ trait that allows language-specific logic for file creation, content prefixing, and directory removal behavior (safe vs. unsafe). It also provides helper methods for computing relative paths between the BAML source and output directories, which is essential for generating correct singleton client references in the final code.
_engine/generators/utils/dir\writer · high confidence
New documentation, configuration, and build infrastructure for the BAML language workspace
The \baml\_language\ directory now includes foundational documentation and configuration files to support the compiler2 architecture and release workflows. This includes \ARCHITECTURE.md\ and \TYPE\_SYSTEM.md\ detailing the compiler pipeline and type semantics, \RELEASING.md\ and \TEST\_INSTRUCTIONS.md\ for operational procedures, and \Cross.toml\ for configuring cross-compilation targets. Additionally, \.gitignore\ and \.insta.yaml\ have been added to manage build artifacts and snapshot testing runners.
_baml\language · high confidence
New editor integration guides and documentation standards
The documentation site now includes dedicated setup and usage guides for VS Code, Cursor, JetBrains IDEs, Zed, and other editors, detailing installation steps, feature support (such as syntax highlighting, LSP integration, and the BAML Playground), and environment variable configuration. Additionally, a \.cursorrules\ file has been added to provide standardized writing guidelines for the documentation team, ensuring consistent tone, structure, and component usage across all docs pages.
fern · high confidence
New event types and wire-capture records for AI runs
The \events.baml\ file introduces a comprehensive catalog of typed events that can appear in a root journal, including \RunStarted\, \UserMessage\, \AssistantMessage\, \ToolRequested\, \ToolCompleted\, \ToolFailed\, \Usage\, and \FinalProduced\. It also defines wire records (\LLMCall\, \Timing\, \HttpResponse\, \SseEventRecord\) to capture detailed HTTP exchange data, timing, and usage statistics for LLM interactions. A \guard\ function is added to wrap event listeners, ensuring that listener errors do not fail or alter a run.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\events · high confidence
New filesystem and glob standard library APIs
The standard library now includes comprehensive filesystem and globbing capabilities. The \baml.fs\ namespace provides functions to open files with read/write/append modes, read and write text or binary content, check existence, get file sizes, and manage directories (create, list, remove single or recursive). It also exposes a \File\ class for streaming operations like seeking and flushing. Additionally, the \baml.glob\ namespace allows compiling glob patterns to scan the filesystem for matching paths or perform pure pattern matching against strings.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\fs · high confidence
New high-performance telemetry ringbuffer and vendored timing library
The engine now includes a new \btel\_ringbuffer\ crate providing a typed, single-producer single-consumer (SPSC) ring buffer for telemetry data, designed for synchronous, spin-waiting producer writes and OS-thread-bound consumers. This component relies on a newly vendored copy of the \quanta\ timing library to handle high-resolution, cross-platform monotonic time measurements and calibration, ensuring accurate timestamping for the telemetry pipeline.
_baml\_language/crates/btel\_ringbuffer, baml\language/vendor/quanta · high confidence
New internal BAML definitions for OpenAI Chat, Images, and Responses APIs
The OpenAI builtin package now includes new internal BAML schema files (\chat.baml\, \images.baml\, \responses.baml\) that define the typed request and response structures for the OpenAI Chat Completions, Images, and Responses APIs. These definitions enable the client to correctly model wire formats, handle provider-specific compatibility flags (such as authentication methods and cache breakpoints), and support new capabilities like image generation and the newer Responses API format within the BAML standard library.
_baml\_language/crates/baml\_builtins2/baml\_std/openai/ns\internal · high confidence
New internal BAML primitives for AWS Bedrock authentication and API modeling
This change introduces new internal BAML files (\auth.baml\ and \bedrock.baml\) that define the wire-format classes and authentication logic for the AWS Bedrock Converse API. Users can now leverage these internal primitives to construct signed requests (using SigV4 via Rust seams for HMAC-SHA256) and model complex Bedrock request structures, including support for various media types (images, video, documents, audio), tool use, and prompt caching checkpoints. These definitions replace previous Rust-only implementations for building Bedrock requests, moving the request construction logic into the BAML standard library while keeping only the cryptographic signing in Rust.
_baml\_language/crates/baml\_builtins2/baml\_std/aws/ns\internal · high confidence
New media types (Image, Audio, Video, Pdf) added to the standard library
The \baml\_std\ namespace now includes four new media classes—\Image\, \Audio\, \Video\, and \Pdf\—defined in \ns\_media/media.baml\. Each class provides a unified interface for handling media content backed by a URL, a local file path, or base64-encoded data. Users can construct these values using factory methods like \from\_url\, \from\_file\, and \from\_base64\, and inspect the underlying source or MIME type via methods such as \url\, \file\, \base64\, and \mime\_type\.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\media · high confidence
New openai-decisions provider for structured decision flows
A new \openai-decisions\ provider has been added to the built-in standard library, enabling structured decision-making workflows. This implementation defines internal classes (\ChoiceOption\, \Leaf\, \Plan\) and functions (\options\, \collect\, \reject\) that leverage reflection (\reflect.Type\, \reflect.Enum\, \reflect.Class\) to traverse type definitions, generate choice options from enums and unions, and construct decision trees with validation for recursive types and field constraints.
_baml\_language/crates/baml\_builtins2/baml\_std/openai/ns\_internal/ns\decisions · high confidence
New operator interfaces for arithmetic, bitwise, comparison, and indexing
The standard library now exposes operator logic through explicit interfaces in \baml.ops\, allowing generic code to require or implement operators via bounds (e.g., \T extends baml.ops.Add\<int\>\). New files define \baml.ops.math\ (Add, Subtract, Multiply, Divide, Remainder, Negate), \baml.ops.bitwise\ (BitAnd, BitOr, BitXor, ShiftLeft, ShiftRight), \baml.ops.comparison\ (Equals, Compare, and the broad \equals\_equals\ driver), and \baml.ops.index\ (Index for arrays, maps, and uint8arrays). These interfaces ensure that operator expressions like \a + b\ or \a\[i\]\ behave consistently whether operand types are known statically or reached through generic bounds, with detailed rules for type widening, panic behavior, and total ordering semantics.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\ops · high confidence
New playground-server component for IDE integration and credential management
The engine/playground-server introduces a new HTTP server that bridges the IDE extensions (VS Code and JetBrains) with the playground webview. It provides RPC endpoints for managing playground settings, loading AWS and GCP credentials, and retrieving webview URIs, while handling WebSocket communication to relay LSP notifications. The server also manages its own port allocation and serves the playground frontend assets, downloading them from GitHub releases when not in debug mode.
engine/playground-server · high confidence
New product metrics dashboard and Slack reporting
The app-product-metrics application now provides a weekly product metrics dashboard and Slack reports. The dashboard (app.ts) renders four Plotly charts—Total Discord users, Distinct GitHub issue authors, Sheep Council activity, and Early Access Program (Luma) attendance—alongside embedded PostHog panels for PLG CLI and Website metrics. Weekly data is aggregated via aggregate-weekly-metric.js, pulling from Discord, GitHub, PostHog, Luma, and Zoom clients, and stored in the database. Slack reports are generated using chart-image.ts and chart-svg.ts to create PNG/SVG visualizations of CLI metrics (invocations, distinct users, retention, release mix) and posted via slack.ts. Tests in aggregate-weekly-metric.test.ts, app.test.ts, and dashboard-capture.test.ts verify the aggregation logic, dashboard rendering, and dashboard capture composition.
typescript2/app-product-metrics · high confidence
New random number generation interface and implementations
The standard library now provides a unified \Rng\ interface for random number generation, implemented by three distinct classes: \SystemRandom\ for cryptographically secure, non-deterministic randomness; \Xoshiro256PlusPlus\ for fast, deterministic, seedable pseudo-randomness suitable for simulations; and \ChaCha20\ for secure, seedable pseudo-randomness. These implementations expose \random\ (for byte arrays) and \random\_int\ (for full-range integers) functions, allowing users to choose the appropriate trade-off between security, determinism, and performance for their specific needs.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\random · high confidence
New reflection standard library package
The \reflect\ package is now available as a prelude in the standard library, providing runtime introspection and type construction capabilities. Users can inspect type metadata, retrieve field and interface details, and dynamically build class and enum definitions at runtime using the new \reflect.Class\, \reflect.Enum\, and \reflect.Builder\ APIs. The package also introduces structured error handling for reflection operations and exposes diagnostic information for runtime compilation.
_baml\_language/crates/baml\_builtins2/baml\std/reflect · high confidence
New shadcn/ui component library added to the UI package
The \typescript/packages/ui\ package now includes a comprehensive set of accessible UI components (such as Accordion, Dialog, Button, and Command) generated using the shadcn/ui CLI with the 'new-york' style. This addition introduces a new \components.json\ configuration file and a \postcss.config.mjs\ file to support the Tailwind CSS setup, providing a standardized, themeable foundation for the application's interface.
typescript/packages/ui · high confidence
New standard library builtins and media support in the compiler2 pipeline
The \baml\_builtins2\ crate now provides the embedded standard library definitions and runtime support for the new compiler2 pipeline. This includes a comprehensive set of built-in types and namespaces (such as \baml\, \reflect\, \ai\, \io\, \http\, \crypto\, and \time\) defined via embedded \.baml\ files and manifests. It introduces native support for media values (images, audio, video, PDFs) with content resolution from URLs, files, or base64, and adds a structured \PromptAst\ representation that allows prompts to be flattened into chat messages, rendered as text, and handled with media placeholders. Additionally, it embeds language reference documentation and TypeScript crosswalk data to power CLI \describe\ commands and editor tooling.
_baml\_language/crates/baml\builtins2/src · high confidence
New standard library clients for OpenAI, Azure, Ollama, and OpenRouter
The \openai\ standard library package now provides dedicated client classes for connecting to various LLM providers. \ChatClient\ targets OpenAI's Chat Completions API, while \ResponsesClient\ supports the newer Responses API. \AzureClient\ handles Azure OpenAI deployments with specific configuration for API keys and versions. \GenericClient\ allows connections to any OpenAI-compatible server (like vLLM or LM Studio), and \OllamaClient\ and \OpenRouterClient\ provide specialized support for local Ollama instances and the OpenRouter gateway, respectively. An \ImageClient\ is also included for OpenAI's image generation models. These clients share a common structure for credential resolution, timeout handling, and wire capture, simplifying the integration of diverse LLM services.
_baml\_language/crates/baml\_builtins2/baml\std/openai · high confidence
New standard library utilities for string dedentation, project identification, and random naming
The \engine/bstd\ module now exposes a set of new standard library functions for use in templates and configurations. Users can now dedent multi-line strings to remove common leading whitespace, validate and parse fully-qualified project names (e.g., \org/project\) with strict naming rules, and generate random animal-based identifiers (e.g., \fox-123\) for unique naming needs. These utilities are now available as part of the built-in standard library.
engine/bstd · high confidence
New stdlib similarity matrix visualization
Added a new interactive matrix app that visualizes the similarity and differences between the BAML and TypeScript standard libraries. The app loads a JSON report and allows users to switch views between BAML and TypeScript, displaying a hierarchical tree of symbols with color-coded swatches to indicate matches, divergences, or missing counterparts. It supports deep-linking to specific symbols via URL fragments and allows modifier-clicking type references to navigate to their declarations.
typescript2/app-stdlib-matrix · high confidence
New system process execution and pipe APIs
The \baml.sys\ namespace now exposes a comprehensive set of types and functions for interacting with the operating system's process model. Users can spawn external programs using \exec\ and \start\_process\, configuring behavior via \ProcessOptions\ (including working directory, environment variables, timeouts, and stdin/stderr handling). The standard error output can be piped, inherited, or discarded via the new \StderrMode\ enum. Process management is handled through the \Process\ class, which provides methods to \wait\, \kill\, and \close\ child processes, returning status via \ProcessExit\. Output streams are abstracted into \ReadPipe\ and \WritePipe\ classes, with \ReadPipe\ supporting line-oriented iteration via \ReadPipeLines\ for convenient text processing. The \ShellOutput\ class aggregates stdout and stderr bytes along with the exit code for synchronous execution results.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\sys · high confidence
New trace module with invocation-level controls and context patching
A new \trace\ module is introduced, providing BAML users with fine-grained control over tracing behavior for individual invocations. Users can now select between Hidden, Timing, and Span modes to determine what data is recorded, and configure value capture for inputs, outputs, and errors. The module exposes a \context\ function that allows patching invocation metadata (such as adding a phase label) via the \$trace\ parameter, enabling more structured and contextual logs without affecting descendant invocations. Additionally, users can retrieve the current invocation's unique SpanId and inspect the active tracing settings.
_baml\_language/crates/baml\_builtins2/baml\std/trace · high confidence
New wire protocol helpers for credential resolution and request redaction
The \wire.baml\ module introduces shared BAML functions that standardize how LLM client authors handle authentication and security on the wire. It adds \resolve\_credential\ to unify credential lookup logic (supporting literals, environment references, and fallbacks) and ensures blank values are treated consistently as unconfigured. It also provides \redact\_url\_secrets\ and \redact\_request\_headers\ to scrub sensitive data (API keys, tokens, authorization headers) from error messages and request snapshots before they are recorded in \ai.events.LLMCall\, preventing accidental leakage of secrets in logs or diagnostics.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\wire · high confidence
OpenAPI generator now supports BamlImage, BamlAudio, BamlPdf, and BamlVideo types
The OpenAPI generator now includes built-in schema definitions for binary media types (images, audio, PDFs, and videos). These types are exposed as union schemas allowing either a base64-encoded string with a media type or a URL, ensuring generated API clients can correctly handle binary content alongside standard data types.
engine/generators/languages/openapi · high confidence
Playground application scaffolded with Vite and Storybook
The playground application has been initialized with a new build and development infrastructure. It now uses Vite as the build tool, configured to serve the app on port 3030 and support WASM modules via \vite-plugin-wasm\. The entry point (\src/main.tsx\) includes logic to listen for VS Code theme updates from the parent window, ensuring the playground UI matches the editor's appearance. Storybook has been added for component development, with configuration files (\main.ts\, \preview.ts\) and initial stories for the \ApiKeysDialog\ component. The application shell (\App.tsx\) integrates the \BAMLSDKProvider\, \ThemeProvider\, and a WASM panic notification handler.
typescript/apps/playground · high confidence
Python SDK bridge layer and runtime initialization
The Python SDK now includes a new \baml\_bridge\ package that serves as the core bridge layer between Python and the BAML runtime. This package provides the \BamlRuntime\ singleton for initialization, protobuf encoding/decoding, and function/method factories consumed by generated SDK code. It introduces a new stub generation script (\generate\_stubs.py\) to produce \.pyi\ type stubs from the PyO3 Rust extension, ensuring accurate type checking for users. The bridge also implements detailed execution environment handling for Python callbacks, specifying how synchronous and asynchronous callbacks interact with threads, event loops, and \ContextVars\, as well as how cancellation and closure invocations are managed.
_baml\language/sdks/python · high confidence
Python client introduces AbortController and structured error handling
The Python client now exposes an AbortController class that allows users to programmatically cancel running BAML function calls or set a timeout for automatic cancellation. Additionally, the client provides a comprehensive set of structured exception types (BamlError, BamlInvalidArgumentError, BamlClientError, BamlAbortError, etc.) that expose detailed context such as prompts, raw outputs, and status codes, replacing generic exceptions with specific, inspectable error objects.
_engine/language\_client\python · high confidence
Rust SDK: Initial client generation with sync/async support and streaming callbacks
The Rust code generator now produces a complete \baml\_client\ module containing both synchronous (\BamlSyncClient\) and asynchronous (\BamlAsyncClient\) entry points, each exposing per-function structs with \call\, \stream\, \parse\, and \build\_request\ methods. The generated runtime includes \FunctionOptions\ that allow configuring collectors, tags, environment variables, cancellation tokens, client selection, and a new \on\_tick\ callback for streaming progress. Additionally, the generator emits type definitions for classes, enums, unions, and type aliases (with serde and BAML encoding/decoding), streaming type variants, and a \TypeBuilder\ for dynamic schema construction at runtime.
engine/generators/languages/rust · high confidence
Rust client generation and strict version compatibility checks
The generator library now supports producing Rust SDK clients alongside existing languages (Go, Python, TypeScript, Ruby, OpenAPI) via the new \generators\_rust\ module. Additionally, a new version-checking mechanism enforces that the generator version matches the runtime version; if they differ, generation is disabled and users receive specific upgrade instructions for their target language (e.g., \cargo add\, \pip install\, \npm install\).
_engine/generators/utils/generators\lib · high confidence
SAP deserializer introduces streaming-aware type coercion and value representation
The \bex\_sap\ crate now includes a complete type coercion and value representation layer for the SAP parser. This adds a \BamlValue\ type system that explicitly models streaming states (\Pending\, \Incomplete\, \Complete\) and supports serialization of primitives, including \BigInt\ as strings to preserve precision. The new deserializer logic handles complex type coercion for arrays, maps, classes, enums, and literals, implementing features such as alias-aware field matching, union variant selection, and strict validation for map keys.
_baml\_language/crates/bex\sap · high confidence
Speedtest now measures BAML VM, Node, Bun, and Python with in-process KPI reporting
The speedtest tool has been updated to support measuring multiple runtime implementations, including the BAML VM (with configurable telemetry levels), Node.js, Bun, and Python. It now uses in-process drivers to capture detailed Key Performance Indicators (KPIs) such as elapsed time, CPU usage, and peak memory, providing a more comprehensive comparison of performance across these different environments.
speedtest · high confidence
Static type checking and type narrowing for Jinja templates
The Jinja engine now includes a static type checker that validates template expressions and statements against defined types. This feature introduces type narrowing, allowing the engine to infer more specific types within conditional branches (e.g., treating a \T \| None\ variable as \T\ inside an \if\ block). It also provides improved error messages with suggestions for undefined variables and invalid function arguments, and enforces stricter typing for enum comparisons and function calls.
engine/baml-lib/jinja · high confidence
Structured error handling with context, stack traces, and first-class UnknownError
The BAML standard library now provides structured error types and context tracking. Users can access detailed error context via \catch (e, ctx)\, where the \Context\ object exposes the original error, a \StackTrace\ (with file, line, and function details), and a \cause\ chain for nested exceptions, including a \root\_cause\ method and Python-style string rendering. New specific error classes like \InvalidArgument\, \ParseError\, \Io\, \Timeout\, \Unsupported\, \AccessError\, \RenderPrompt\, \LlmClient\, \HostCallable\, \GenericSdkError\, \CompilationError\, and \TypeMismatch\ allow for precise error identification. Additionally, the \UnknownError\ class offers a universal wrapper for untyped errors, supporting message appending and context preservation through \from\<T\>\ and \with\_message\ methods.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\errors · high confidence
Unified SDK test codegen infrastructure for C++, C\#, Go, Java, Python, Rust, Swift, and TypeScript
The \sdk\_tests/codegen\ crate now provides a centralized, generator-agnostic codegen driver that produces SDK bindings for all supported languages from a shared fixture corpus. This new infrastructure replaces per-language build scripts with a single \sdk\_test\_codegen\ binary that orchestrates the generation process, ensuring consistent output across C++, C\#, Go, Java, Python (pydantic2), Rust, Swift, and TypeScript. Each language generator now handles its specific build configuration (such as CMake for C++, Gradle for Java, and Swift Package Manager for Swift) while sharing common test harness logic, resulting in a more maintainable and reliable test suite for SDK consumers. Also in this area: Rust SDK: Enable JSON serialization tests and optional serde features.
_baml\_language/sdk\tests/codegen · high confidence
Unified compiler diagnostic system with multi-format rendering
The BAML compiler now uses a single, unified \Diagnostic\ type to represent errors across all compilation phases (parsing, HIR lowering, validation, and type checking). This change introduces structured error types for parse, type, and name errors, enabling consistent error handling and centralized rendering. Users will see improved diagnostic output with support for multiple formats: human-readable CLI output with syntax highlighting and source snippets, compact agent-friendly output, concise one-line formats for testing, and LSP integration for editor support. The system also includes runtime type validation diagnostics and semantic highlighting for diagnostic messages.
_baml\_language/crates/baml\_compiler\diagnostics · high confidence
Unified type system with canonical type representation and runtime call layouts
The type system has been consolidated into a single \baml\_type\ crate, introducing a canonical \Ty\ enum that unifies compiler and runtime type representations. This change introduces \CallLayout\ to standardize how function arguments are mapped between callers and callees, ensuring consistent dispatch behavior. It also adds \CodegenTy\ for generator-independent type normalization, \CompilerAlias\ for managing builtin type spellings, and \DeclarationName\ to distinguish between source-compiled and runtime-created declarations. Additionally, the crate now includes \TyAttr\ for type attributes (such as SAP streaming annotations), \SchemaDefs\ for canonical schema definitions, and \Int63\ for precise 63-bit integer semantics, providing a unified foundation for type checking, code generation, and runtime execution.
_baml\_language/crates/baml\type · high confidence
Updated vendored MiniJinja and MiniJinja-Contrib template engine
The vendored MiniJinja engine and its contrib utilities have been updated to a new version. This update introduces new template filters and global functions, including \datetimeformat\, \timeformat\, and \dateformat\ for date/time handling, \pluralize\, \filesizeformat\, and \truncate\ for text manipulation, as well as \random\, \lipsum\, and \randrange\ for randomization. It also adds Python compatibility methods for strings, lists, and maps via the \pycompat\ feature, and provides utility functions like \cycler\ and \joiner\. The core compiler and AST structures have been updated to support these new features and internal optimizations.
engine/vendored/minijinja, engine/vendored/minijinja-contrib · high confidence
Workflow rendering and debugging UI components
Added a new debug panel for inspecting BAML functions and workflow nodes, a hook to synchronize execution state with the visual graph, and workflow UI controls including a toolbar for running workflows and switching layout directions, plus an indicator that lets users switch between workflows when a node belongs to multiple definitions.
typescript/packages/playground-common/src/features/debug-panel, typescript/packages/playground-common/src/features/execution, typescript/packages/playground-common/src/features/workflow · high confidence
Removals
Removal of Gloo-based client and pipeline definitions in test1
The \client-tests/test1\ location has removed its core Gloo source files, including \clients.gloo\, \main.gloo\, and the pipeline modules (\message\_simplifier.gloo\, \text\_polisher.gloo\, \topic\_router.gloo\). This deletes the previously defined LLM client configurations (Azure OpenAI), data models (Message, Conversation), and the logic for the message simplifier, text polisher, and topic router pipelines. This change aligns with the project's shift toward TypeScript support, indicating these specific Gloo-based definitions are no longer part of this test area's implementation.
client-tests/test1 · high confidence
Removal of Python test application entry point
The main entry point script for the Python test application (app/main.py) has been removed. This file previously contained the logic for running Azure default and topic router tests using the generated clients and functions, along with tracing capabilities. Its deletion indicates that this specific test execution path is no longer part of the codebase.
client-tests/test1/python · high confidence
Removal of custom user event sending capability
The \baml.events.send\ intrinsic has been removed from the runtime, meaning users can no longer send custom user events. The \ns\_events\ namespace is now intentionally empty as the system transitions to a new observability architecture.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\events · high confidence
Removal of deprecated Python client implementation
The \clients/python\ directory, including the \gloo\_internal\ and \gloo\_py\ packages, has been completely removed. This deletes the internal API wrapper, LLM client implementations (OpenAI, Anthropic), tracing infrastructure, and type definitions that were previously exposed to users. Users relying on this Python client package will no longer have access to these capabilities.
clients · high confidence
Removal of legacy Python client test artifacts
The legacy Python test setup for \client-tests/test1\ has been removed, specifically deleting the \.gitignore\ file, the \gloo.yaml\ configuration, and the \src\ symbolic link. This cleanup eliminates obsolete build and generation artifacts from the test directory.
client-tests · high confidence
Removal of the C++ CLI codebase
The CLI directory, including the Rust build script and the entire C++ source tree (AST, tokenizer, and code generation logic), has been removed. This eliminates the local C++ compilation and code-generation capabilities previously provided by the CLI.
cli · high confidence
Removal of the Gloo VS Code extension
The VS Code extension for the Gloo language has been completely removed. This deletes all extension source code, including the main entry point, syntax highlighting definitions, code snippets, and providers for keyword completion and code lenses. Users will no longer have auto-build-on-save, syntax highlighting, or inline test-running capabilities for .gloo files within VS Code.
vscode-ext · high confidence
Architecture
HIR2 introduces span-free semantic indexing and incremental compilation foundations
The \baml\_compiler2\hir\ crate now implements a new High-Level Intermediate Representation (HIR2) architecture that separates semantic data from source spans to enable incremental compilation. By splitting item data into span-free \\\data\ queries (used by type checking) and \\\_source\_map\ queries (used by diagnostics and IDEs), the compiler can now skip re-running type-checking logic on whitespace-only file changes. This new layer introduces a unified attribute lowering system that validates schema attributes against a fixed vocabulary, a robust \SemanticIndexBuilder\ that constructs scope chains and symbol contributions, and Salsa-tracked queries for function and let-binding bodies. These changes provide the structural foundation for faster, content-addressed incremental compilation and improved tooling responsiveness. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
_baml\_language/crates/baml\_compiler2\_hir/src/item\_data, baml\_language/crates/baml\_compiler2\_hir/src/item\tree · low confidence · unverified
Introduce MIR 2 compiler backend with new optimization and lowering infrastructure
The \baml\_compiler2\_mir\ crate now provides a complete Mid-level Intermediate Representation (MIR) pipeline, replacing the previous implementation. This includes a new \MirBuilder\ for constructing function control flow graphs, a \lower.rs\ module for translating high-level semantics into MIR, and a robust optimization suite (\optimize.rs\) that performs dead-code elimination, copy propagation, and constant folding. A new \inference\_provider.rs\ bridges the \hir\_ty\ type inference engine to the MIR layer, ensuring accurate type resolution for the new backend. This change establishes the foundation for improved compiler performance and more precise error reporting in subsequent releases.
_baml\_language/crates/baml\_compiler2\mir · high confidence
New compiler2 HIR infrastructure for semantic indexing and incremental compilation
The \baml\_compiler2\_hir\ crate introduces a new High-Level Intermediate Representation (HIR) layer for the compiler2 pipeline, replacing previous indexing mechanisms. This change adds a scope-tree-based semantic index that maps expressions to lexical scopes and tracks symbol contributions to package namespaces. It introduces position-independent item storage (the ItemTree) and Salsa-tracked queries for function and let-binding bodies, separating semantic data from source spans to enable efficient incremental compilation that skips re-analysis on whitespace-only changes. The module also implements diagnostics for duplicate definitions, interface implementation rules, and pattern binding errors, providing the foundational data structures for the new type inference and code generation phases.
_baml\_language/crates/baml\_compiler2\hir/src · high confidence
Behavioural changes
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 166 files: “Redesign the CLI surface (BEP-086) (\#5583)” (refs \#5583). Also in this area: Improved streaming span lifetime and tracing fidelity.
_baml\_language/demo2, baml\language/examples · low confidence · unverified
1 commit (0 fixes) modifying baml\_language/sdk\_tests/fixtures/unsupported\_only
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/unsupported\_only — 1 commit, 1 file: “feat(go): add generated SDK and standalone runtime release (\#4067)” (refs \#4067).
_baml\_language/sdk\_tests/fixtures/unsupported\only · medium confidence · unverified
10 commits (5 fixes) modifying baml\_language/wrapper\_tests/baml\_src
A change to existing behaviour in baml\_language/wrapper\_tests/baml\_src — 10 commits (5 fixs), 13 files: “fix(wrapper): only auto-install baml-cli on commands that need it (\#5613)”; “fix(stdlib): improve subprocess management API, for the baml wrapper (\#5456)”; “Test that wrapper help after toolchain arguments changes nothing (\#5571)”; and 7 more (refs \#5613, \#5456, \#5571, \#5583, \#5457, …).
_baml\_language/wrapper\_tests/baml\src · medium confidence · unverified
101 commits (28 fixes) modifying baml\_language/crates/baml\_compiler2\_hir\_ty
A change to existing behaviour in baml\_language/crates/baml\_compiler2\_hir\_ty — 101 commits (28 fixs), 35 files: “Reject ai.Role interpolated into untagged strings (\#5486)”; “fix(compiler): infer lambdas from callable union arms (\#4646)”; “feat(reflect): apply the AnyClass follow-up rulings (\#4493)”; and 98 more (refs \#5486, \#4646, \#4493, \#5655, \#5359, …).
_baml\_language/crates/baml\_compiler2\_hir\ty · medium confidence · unverified
11 commits (1 fix) modifying baml\_language/crates/baml\_sdkgen\_types
A change to existing behaviour in baml\_language/crates/baml\_sdkgen\_types — 11 commits (1 fix), 13 files: “Bridge coercion rework (\#5359)”; “Add a package\_name generator setting; Python SDKs import under any name (\#5532)”; “Add @json attributes so a class needs no JSON override (\#5563)”; and 8 more (refs \#5359, \#5532, \#5563, \#5185, \#5005, …).
_baml\_language/crates/baml\_sdkgen\types · medium confidence · unverified
13 commits (3 fixes) modifying baml\_language/sdk\_tests/fixtures/function\_calls/baml\_src/ns\_host\_callable\_tests
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/function\_calls/baml\_src/ns\_host\_callable\_tests — 13 commits (3 fixs), 2 files: “Fix Python and Node callable execution and standardize SDK contracts (\#5061)”; “feat(typescript-web): implement browser and Workers runtimes (\#4006)”; “Bridge coercion rework (\#5359)”; and 10 more (refs \#5061, \#4006, \#5359, \#5185, \#3787, …).
_baml\_language/sdk\_tests/fixtures/function\_calls/baml\_src/ns\_host\_callable\tests · medium confidence · unverified
17 commits (3 fixes) modifying baml\_language/crates/sys\_wasm
A change to existing behaviour in baml\_language/crates/sys\_wasm — 17 commits (3 fixs), 4 files: “feat(typescript-web): implement browser and Workers runtimes (\#4006)”; “GC should use full object memory footprint (\#5155)”; “Bridge coercion rework (\#5359)”; and 14 more (refs \#4006, \#5155, \#5359, \#4496, \#4427, …).
_baml\_language/crates/sys\wasm · medium confidence · unverified
2 commits (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 2 commits, 20 files: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#3558, \#3580).
(repo-wide) · medium confidence · unverified
2 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_complex\_models
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_complex\_models — 2 commits, 1 file: “Overhaul BAML language release pipeline (\#3639)”; “feat(sdk-ts): implement the ts/nodejs SDK generator (\#3614)” (refs \#3639, \#3614).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_complex\models · medium confidence · unverified
20 commits (2 fixes) modifying baml\_language/crates/baml\_parser
A change to existing behaviour in baml\_language/crates/baml\_parser — 20 commits (2 fixs), 60 files: “Paulo/match-3 (\#2867)”; “New unified parser and syntax tree (\#5589)”; “Reorganize the error formatting code (\#2751)”; and 17 more (refs \#2867, \#5589, \#2751, \#2814, \#2939, …).
_baml\_language/crates/baml\parser · medium confidence · unverified
245 commits (66 fixes) modifying baml\_language/crates/baml\_tests/baml\_src
A change to existing behaviour in baml\_language/crates/baml\_tests/baml\_src — 245 commits (66 fixs), 607 files: “fix(emit): materialize bound methods in projection stores (\#5385)”; “fix(compiler): infer lambdas from callable union arms (\#4646)”; “fix: make stream parsing reliable, handle \\\`json (\#5060)”; and 242 more (refs \#5385, \#4646, \#5060, \#5655, \#5041, …).
_baml\_language/crates/baml\_tests/baml\src · medium confidence · unverified
27 commits (3 fixes) modifying baml\_language/crates/baml\_version
A change to existing behaviour in baml\_language/crates/baml\_version — 27 commits (3 fixs), 1 file: “fix(csharp): repair release ABI verification and prepare 0.22.2 (\#5239)”; “Release BAML 0.25.2 (\#5559)”; “chore(release): bump canary to 0.16.0 (\#4368)”; and 24 more (refs \#5239, \#5559, \#4368, \#5237, \#4848, …).
_baml\_language/crates/baml\version · medium confidence · unverified
29 commits (7 fixes) modifying baml\_language/crates/btel\_bcs
A change to existing behaviour in baml\_language/crates/btel\_bcs — 29 commits (7 fixs), 54 files: “Model turns as a tree; requested and resolved models; usage on btel spans (\#5261)”; “Compare btel prepares by file sequence, not arrival order (\#5436)”; “Fix span start times, stack trace frames and failed spans' errors (\#5605)”; and 26 more (refs \#5261, \#5436, \#5605, \#5390, \#5084, …).
_baml\_language/crates/btel\bcs · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_aliases
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_aliases — 3 commits, 2 files: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “bridge-cpp: C ABI header + baml-cpp tarball packaging (slice 0) (\#4004)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#3558, \#4004, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\aliases · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_json\_interchange
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_json\_interchange — 3 commits, 1 file: “Add @json attributes so a class needs no JSON override (\#5563)”; “One name per conversion in baml.json (\#5399)”; “feat(sdk-rust): optional serde impls on generated types (\#5375)” (refs \#5563, \#5399, \#5375).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_json\interchange · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_literals
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_literals — 3 commits, 1 file: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)”; “bridge-cpp: async call form - {name}Async siblings, baml::Future, cancellation, co\_await (\#4078)” (refs \#3558, \#3580, \#4078).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\literals · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_lorem
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_lorem — 3 commits, 3 files: “BEP-075: Simplified Streaming (\#4935)”; “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#4935, \#3558, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\lorem · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_optional
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_optional — 3 commits, 1 file: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “Generate a new constructor for Rust structs that defaults optional fields to None (\#5527)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#3558, \#5527, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\optional · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_primitives
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_primitives — 3 commits, 1 file: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(go): add generated SDK and standalone runtime release (\#4067)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#3558, \#4067, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\primitives · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_void
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_void — 3 commits, 1 file: “Unit type (\#5185)”; “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)” (refs \#5185, \#3558, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\void · medium confidence · unverified
3 commits (0 fixes) modifying baml\_language/sdks/java/examples
A change to existing behaviour in baml\_language/sdks/java/examples — 3 commits, 4 files: “docs(sdk-java): quickstart becomes the one-liner (\#4121)”; “docs(sdk-java): quickstart pins the e2e-verified family nightly (\#4150)”; “feat(sdk-java): Java/JVM bridge — harness, codegen, runtime, first end-to-end slice (\#4060)” (refs \#4121, \#4150, \#4060).
_baml\language/sdks/java/examples · medium confidence · unverified
3 commits (1 fix) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_maps
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_maps — 3 commits (1 fix), 1 file: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(python): wire errors through the bridge, add roundtrip test coverage, and fix test infra/bugs (\#3580)”; “\[codex\] Fix string splitting and map key diagnostics (\#3861)” (refs \#3558, \#3580, \#3861).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\maps · medium confidence · unverified
31 commits (4 fixes) modifying baml\_language/crates/baml\_artifact
A change to existing behaviour in baml\_language/crates/baml\_artifact — 31 commits (4 fixs), 2 files: “Bridge coercion rework (\#5359)”; “BEP-075: Simplified Streaming (\#4935)”; “fix: give catch, catch\_all, catch\_all\_panics consistent semantics (\#5317)”; and 28 more (refs \#5359, \#4935, \#5317, \#5477, \#5563, …).
_baml\_language/crates/baml\artifact · medium confidence · unverified
32 commits (2 fixes) modifying typescript2/app-website
A change to existing behaviour in typescript2/app-website — 32 commits (2 fixs), 238 files: “feat(web): publish releases as blog posts (\#4743)”; “Homepage polish: hero copy, Build section, merged deploy figure, adopt (\#5545)”; “Website: current Boundary logo and the dusk card on the homepage's link preview (\#5590)”; and 29 more (refs \#4743, \#5545, \#5590, \#5602, \#4742, …).
typescript2/app-website · medium confidence · unverified
32 commits (3 fixes) modifying baml\_language/crates/bex\_cache
A change to existing behaviour in baml\_language/crates/bex\_cache — 32 commits (3 fixs), 1 file: “Restore explicit local ID capture plumbing (\#4066)”; “Bridge coercion rework (\#5359)”; “BEP-062 AnyFunction slice: baml.AnyFunction + reflect.signature/call\_any (\#4099)”; and 29 more (refs \#4066, \#5359, \#4099, \#4076, \#4105, …).
_baml\_language/crates/bex\cache · medium confidence · unverified
33 commits (5 fixes) modifying baml\_language/sdk\_tests/crates/rust
A change to existing behaviour in baml\_language/sdk\_tests/crates/rust — 33 commits (5 fixs), 43 files: “Bridge coercion rework (\#5359)”; “sdkgen\_rust: qualify clashing union variant names by namespace (\#5320)”; “BEP-075: Simplified Streaming (\#4935)”; and 30 more (refs \#5359, \#5320, \#4935, \#4045, \#5563, …).
_baml\_language/sdk\tests/crates/rust · medium confidence · unverified
36 commits (5 fixes) modifying baml\_language/sdks/rust/sdkgen\_rust
A change to existing behaviour in baml\_language/sdks/rust/sdkgen\_rust — 36 commits (5 fixs), 16 files: “Bridge coercion rework (\#5359)”; “sdkgen\_rust: qualify clashing union variant names by namespace (\#5320)”; “BEP-075: Simplified Streaming (\#4935)”; and 33 more (refs \#5359, \#5320, \#4935, \#4045, \#5563, …).
_baml\_language/sdks/rust/sdkgen\rust · medium confidence · unverified
4 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_go\_codegen
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_go\_codegen — 4 commits, 12 files: “Enable the Python SDK migration primitives used by VetRec (\#4459)”; “Decode class-union fields to their Go structs in generic decoding (\#5511)”; “feat(go): add generated SDK and standalone runtime release (\#4067)”; and 1 more (refs \#4459, \#5511, \#4067, \#4147).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_go\codegen · medium confidence · unverified
4 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_media
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_media — 4 commits, 1 file: “Redesign FunctionSpec and streaming projections (\#4623)”; “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(go): expand generated SDK completeness (\#4147)”; and 1 more (refs \#4623, \#3558, \#4147, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\media · medium confidence · unverified
4 commits (0 fixes) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_unions
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_unions — 4 commits, 1 file: “tests: update sdk\_tests to support nodejs and python (\#3558)”; “feat(sdk-java): Java/JVM bridge — harness, codegen, runtime, first end-to-end slice (\#4060)”; “feat: upstream SDK codegen and runtime foundations (\#4087)”; and 1 more (refs \#3558, \#4060, \#4087, \#3580).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\unions · medium confidence · unverified
4 commits (1 fix) modifying baml\_language/crates/baml\_compiler2\_metrics
A change to existing behaviour in baml\_language/crates/baml\_compiler2\_metrics — 4 commits (1 fix), 6 files: “New unified parser and syntax tree (\#5589)”; “Add \baml codequality\ command for code complexity metrics (\#5424)”; “fix(compiler): type union interface members per arm and record the dispatch view (\#5632)”; and 1 more (refs \#5589, \#5424, \#5632, \#5453).
_baml\_language/crates/baml\_compiler2\metrics · medium confidence · unverified
4 commits (1 fix) modifying baml\_language/sdks/rust/verify
A change to existing behaviour in baml\_language/sdks/rust/verify — 4 commits (1 fix), 3 files: “Initial rust bridge (\#4045)”; “Stop the Rust bridge from turning on serde\_json's arbitrary\_precision and preserve\_order (\#5509)”; “Fix Rust and C++ release verification regressions (\#4118)”; and 1 more (refs \#4045, \#5509, \#4118, \#5519).
_baml\language/sdks/rust/verify · medium confidence · unverified
44 commits (6 fixes) modifying baml\_language/crates/baml\_tests/src/compiler2\_mir
A change to existing behaviour in baml\_language/crates/baml\_tests/src/compiler2\_mir — 44 commits (6 fixs), 2 files: “Restore explicit local ID capture plumbing (\#4066)”; “Native \json\ type: alias, parse/stringify, auto-derived to\_json/from\_json (\#3484)”; “\[codex\] implement iterable for loops (\#3705)”; and 41 more (refs \#4066, \#3484, \#3705, \#4935, \#5477, …).
_baml\_language/crates/baml\_tests/src/compiler2\mir · medium confidence · unverified
55 commits (8 fixes) modifying baml\_language/crates/baml\_tests/snapshots/baml\_src
A change to existing behaviour in baml\_language/crates/baml\_tests/snapshots/baml\_src — 55 commits (8 fixs), 78 files: “feat: add TypeSafe JEV client, implemented with reflection (\#4938)”; “feat!: fix azure client behavior (\#5133)”; “Model turns as a tree; requested and resolved models; usage on btel spans (\#5261)”; and 52 more (refs \#4938, \#5133, \#5261, \#4935, \#5317, …).
_baml\_language/crates/baml\_tests/snapshots/baml\src · medium confidence · unverified
6 commits (1 fix) modifying baml\_language/crates/baml\_tests/rust\_diff
A change to existing behaviour in baml\_language/crates/baml\_tests/rust\_diff — 6 commits (1 fix), 12 files: “Bridge coercion rework (\#5359)”; “Build a chain of string + in one step (\#5477)”; “Escape analysis: both backends skip locks on task-local objects (\#5498)”; and 3 more (refs \#5359, \#5477, \#5498, \#5264, \#5531, …).
_baml\_language/crates/baml\_tests/rust\diff · medium confidence · unverified
7 commits (0 fixes) modifying baml\_language/crates/sys\_auth
A change to existing behaviour in baml\_language/crates/sys\_auth — 7 commits, 5 files: “Redact credentials in google + aws errors (\#5494)”; “Native BAML LLM provider clients: delete sys\_llm, auth-only Rust (\#4430)”; “Consolidate BAML environment variables (\#5131)”; and 4 more (refs \#5494, \#4430, \#5131, \#5054, \#4725, …).
_baml\_language/crates/sys\auth · medium confidence · unverified
7 commits (1 fix) modifying baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_generics
A change to existing behaviour in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_generics — 7 commits (1 fix), 2 files: “BEP-075: Simplified Streaming (\#4935)”; “tests: update sdk\_tests to support nodejs and python (\#3558)”; “generic tests (\#3780)”; and 4 more (refs \#4935, \#3558, \#3780, \#3702, \#3580, …).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\generics · medium confidence · unverified
7 commits (3 fixes) modifying baml\_language/wrapper
A change to existing behaviour in baml\_language/wrapper — 7 commits (3 fixs), 31 files: “fix(wrapper): only auto-install baml-cli on commands that need it (\#5613)”; “fix(wrapper): drain discarded HTTP bodies to complete BCS spans (\#5623)”; “Add a package\_name generator setting; Python SDKs import under any name (\#5532)”; and 4 more (refs \#5613, \#5623, \#5532, \#5583, \#5422, …).
_baml\language/wrapper · medium confidence · unverified
7 commits (3 fixes) modifying baml\_language/wrapper\_tests
A change to existing behaviour in baml\_language/wrapper\_tests — 7 commits (3 fixs), 5 files: “fix(wrapper): only auto-install baml-cli on commands that need it (\#5613)”; “Test that wrapper help after toolchain arguments changes nothing (\#5571)”; “Redesign the CLI surface (BEP-086) (\#5583)”; and 4 more (refs \#5613, \#5571, \#5583, \#5422, \#5514, …).
_baml\_language/wrapper\tests · medium confidence · unverified
74 commits (14 fixes) modifying baml\_language/sdk\_tests/crates/python\_pydantic2
A change to existing behaviour in baml\_language/sdk\_tests/crates/python\_pydantic2 — 74 commits (14 fixs), 61 files: “Fix Python and Node callable execution and standardize SDK contracts (\#5061)”; “Bridge coercion rework (\#5359)”; “feat(typescript-web): scaffold the Web bridge release (\#4052)”; and 71 more (refs \#5061, \#5359, \#4052, \#4051, \#5261, …).
_baml\_language/sdk\_tests/crates/python\pydantic2 · medium confidence · unverified
8 commits (0 fixes) modifying baml\_language/tools/speedtest/workloads
A change to existing behaviour in baml\_language/tools/speedtest/workloads — 8 commits, 296 files: “Build a chain of string + in one step (\#5477)”; “Read and write JSON without an intermediate serde\_json tree (\#5402)”; “Cache interface impl resolution across calls (\#5418)”; and 5 more (refs \#5477, \#5402, \#5418, \#5399, \#5496, …).
_baml\language/tools/speedtest/workloads · medium confidence · unverified
8 commits (0 fixes) modifying typescript2/app-beps
A change to existing behaviour in typescript2/app-beps — 8 commits, 31 files: “BEPs: API tokens for invited collaborators outside the org (\#5646)”; “BEPs BCS: decisions and open issues (\#5648)”; “BEPs BCS: GitHub avatars on comments and stances (\#5653)”; and 5 more (refs \#5646, \#5648, \#5653, \#5650, \#5636, …). Also in this area: 4 commits (1 fix) modifying typescript2/app-beps; BEP Feedback app migrated to TypeScript 2 with Next.js App Router.
.trunk, typescript2/app-beps · medium confidence · unverified
8 commits (1 fix) modifying baml\_language/tools/type\_quiz/ns\_conformance
A change to existing behaviour in baml\_language/tools/type\_quiz/ns\_conformance — 8 commits (1 fix), 15 files: “Add a static type() method to every type (\#5272)”; “Fix type system quiz tells (\#4963)”; “One name per conversion in baml.json (\#5399)”; and 5 more (refs \#5272, \#4963, \#5399, \#5037, \#5268, …).
_baml\_language/tools/type\_quiz/ns\conformance · medium confidence · unverified
8 commits (1 fix) modifying packaging
A change to existing behaviour in packaging — 8 commits (1 fix), 28 files: “feat(release): build package-manager wrappers without self-update (\#4166)”; “Overhaul BAML language release pipeline (\#3639)”; “Redesign the CLI surface (BEP-086) (\#5583)”; and 5 more (refs \#4166, \#3639, \#5583, \#3559, \#5557, …).
packaging · medium confidence · unverified
9 commits (2 fixes) modifying baml\_language/crates/baml\_tests/snapshots/broken\_syntax/parser\_speculative, baml\_language/crates/baml\_tests/snapshots/broken\_syntax/pending\_greaters\_fix
A change to existing behaviour in baml\_language/crates/baml\_tests/snapshots/broken\_syntax/parser\_speculative, baml\_language/crates/baml\_tests/snapshots/broken\_syntax/pending\_greaters\_fix — 9 commits (2 fixs), 2 files.
(repo-wide) · medium confidence · unverified
9 commits (2 fixes) modifying baml\_language/tools/type\_quiz/ns\_engine
A change to existing behaviour in baml\_language/tools/type\_quiz/ns\_engine — 9 commits (2 fixs), 18 files: “Unit type (\#5185)”; “Add a static type() method to every type (\#5272)”; “Fix type system quiz tells (\#4963)”; and 6 more (refs \#5185, \#5272, \#4963, \#5399, \#5357, …).
_baml\_language/tools/type\_quiz/ns\engine · medium confidence · unverified
CFFI layer refactored to use a buffer-only serialization pattern
The CFFI interface in the language client has been migrated to a buffer-only pattern, replacing previous direct pointer passing with serialized byte buffers (via Prost). This change introduces new modules for encoding and decoding BAML values, types, and function arguments across the boundary, and wraps result and error callbacks in \tokio::task::block\_in\_place\ to prevent deadlocks when the host language performs blocking FFI calls. The refactoring also adds a panic handler for buffer encoding to ensure errors are safely propagated to the host rather than crashing the process.
_engine/language\_client\cffi · high confidence
Generated Python client now uses Pydantic v1 models with explicit descriptions and streaming support
The generated Python client code in \integ-tests/python-v1/baml\_client\ has been updated to use Pydantic v1 \BaseModel\ classes instead of previous implementations. This change introduces \StreamState\ generic models to support streaming outputs, adds \Field(description=...)\ annotations to propagate BAML descriptions to the generated Pydantic models, and ensures generated classes include \Config.arbitrary\_types\_allowed = True\ to handle complex types like \baml\_py.Image\. Users will see generated models that strictly follow Pydantic v1 semantics, with preserved field orders and explicit metadata for documentation.
python-v1 · high confidence
Go CLI entry point allows 'baml' command invocation
A new Go-based entry point has been added to the baml directory, enabling users to invoke the CLI using the 'baml' command. This change addresses a Go-specific requirement where the package folder name must match the package name, ensuring the CLI works correctly when invoked as 'baml' rather than requiring a different binary name.
baml · high confidence
Go SDK CFFI header introduces BAML API V1 revision 4 with unified media and handle types
The Go SDK's CFFI include file (baml\_cffi.h) now defines ABI revision 4, which changes the media model so that media values hold content directly rather than file paths, and consolidates handle types for functions, media, prompts, and runtime values. This header establishes the stable C interface contract for the Go bridge, including platform-specific calling conventions and status codes, ensuring the Go SDK aligns with the unified invocation and media semantics used across other SDK bridges.
_baml\_language/sdks/go/baml\go/internal/cffi/include · high confidence
Host-supplied JSON values now materialize with container typing for consistent behavior
JSON values passed from the host environment are now materialized with \baml.json.json\ container typing, ensuring they behave identically to JSON values created within BAML (e.g., via \baml.json.parse\). This change enables reliable type narrowing using \match\ expressions and ensures that path extraction functions like \baml.json.path\ and \baml.json.path\_or\ work correctly on host-supplied data, resolving previous inconsistencies where such operations might have failed or behaved unexpectedly on external input.
_baml\_language/sdk\_tests/fixtures/function\_calls/baml\_src/ns\_go\_json\tests · high confidence
Improved diagnostic accuracy and reduced cascading errors in the BAML compiler
The BAML compiler now provides clearer, more precise error reporting for a wide range of language constructs, significantly reducing confusing cascading diagnostics. Key improvements include: stricter type checking for backtick string interpolation (B-836), which now catches type errors inside \${...}\ expressions at compile time rather than failing at runtime; validation of duplicate attributes (E0014) and duplicate serialized keys for class fields (B-615) and enum variants (B-649), preventing unsatisfiable schemas; better handling of attribute placement and ordering (e.g., rejecting field attributes in non-field positions); and more robust error recovery for catch/throw blocks, ensuring return-type mismatches are reported cleanly. Additionally, the compiler now correctly rejects invalid generic type arguments on builtin types and enforces stricter typing for \reflect.AnyFunction\ usage. Also in this area: 3 commits (2 fixes) fixing baml\_language/crates/baml\_tests; 1 commit (0 fixes) modifying (repo-wide); LLM output parsing now respects custom type shapes via FromLlmOutput; Unified compilation pipeline and JSON API simplification; HTTP client reuse and improved type checking for unions and nullable types.
_baml\_language/crates/baml\_tests/projects/diagnostic\errors · low confidence · unverified
Internal AI provider plumbing and authentication primitives
This change introduces a new internal \ai\ package layer (\ns\_internal\) that consolidates the low-level plumbing for AI provider interactions. It adds internal BAML functions for provider authentication (including Google Cloud OAuth2 token minting and AWS SigV4 request signing), client resolution from shorthand strings, and HTTP error classification (specifically parsing retry-after headers). It also implements internal helpers for prompt assembly (handling role markers and cache delimiters), media output parsing and resolution (supporting image, audio, video, and PDF types with URL fetching and base64 encoding), and request body merging. These components serve as the private implementation details for the public \ai\ surface, handling credential normalization, wire-format serialization, and token accounting.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\internal · high confidence
Internal host callable invocation mechanism and opaque Value type
The standard library now includes an internal \call\_host\_value\ function and an opaque \Value\ class within the \ns\_host\ module. \call\_host\_value\ serves as the compiler-synthesized bridge for invoking host-side callables, handling type validation for return values and errors against declared contracts (raising \baml.panics.HostContractViolation\ on mismatch) and managing argument packing. The \Value\ class is an empty, non-instantiable type reserved for the bridge boundary to represent external values, preventing users from constructing or destructuring it directly.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\host · high confidence
Introduce new prompt parser AST and grammar
The prompt parser now uses a dedicated Abstract Syntax Tree (AST) structure defined in the \ast\ module, replacing previous internal representations. This change introduces specific node types for top-level schema elements, including \CodeBlock\ (for variables, print blocks, and chat blocks), \CommentBlock\, \PromptText\, and \WhiteSpace\. The parser logic, driven by a new \datamodel.pest\ grammar file, has been updated to recognize and parse these distinct segments, allowing for more robust handling of prompt structures and whitespace.
engine/baml-lib/prompt-parser · high confidence
Introduce structured diagnostics with pretty-printed error and warning reporting
The diagnostics subsystem now uses a new \Diagnostics\ collection to accumulate and display validation errors and warnings together, rather than failing immediately on the first issue. This change introduces structured \DatamodelError\ and \DatamodelWarning\ types that include source spans, enabling the engine to output human-readable, color-coded messages that highlight the specific offending code lines. Additionally, the system now provides intelligent suggestions for typos (e.g., suggesting similar type names when a type is not found) and supports adjusting error spans for accurate reporting in transformed code contexts.
engine/baml-lib/diagnostics · high confidence
Introduces BTEL v2 telemetry recording format and encoder
The \btel\_recorder\ crate now implements the BTEL v2 wire format, replacing the previous telemetry structure. This change introduces a new Protobuf schema (\recording.proto\) that defines the \RecordingFile\ container and its sections (spans, definitions, aggregates, clock states, errors, and usage). The crate now includes a synchronous encoder (\encoding.rs\) that converts in-memory telemetry records into this new binary format, supporting features like context-aware span sections, structured error evidence, and network spans. This foundational shift enables the recording of richer execution details, such as source maps, function argument layouts, and process launch context, while maintaining backward compatibility through format versioning.
_baml\_language/crates/btel\recorder · high confidence
Introduction of the BAML Virtual Machine
The BAML engine now executes workflows using a new stack-based virtual machine (VM) instead of the previous interpreter. This VM introduces a defined bytecode instruction set (including operations for arrays, maps, and class instances), typed object pools for safer memory management, and a reachability-based graph system to handle the \@watch\ dependency tracking. It also provides native support for JavaScript-compatible string and number methods, media type handling, and environment variable access, while offering detailed stack traces and debug visualization for runtime errors.
engine/baml-vm · high confidence
Introduction of typed panic classes for runtime errors
The BAML standard library now defines a set of specific, typed classes (such as DivisionByZero, IndexOutOfBounds, IntegerOverflow, and HostContractViolation) to represent runtime panics. This change replaces generic error handling with structured types that carry context (like the offending index or message), allowing users to catch and inspect specific failure modes rather than dealing with opaque errors.
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\panics · high confidence
Jinja runtime migrated to MiniJinja with improved enum and class rendering
The Jinja template engine in the BAML runtime has been replaced with MiniJinja, introducing more robust handling of BAML-specific types. Enum values now display their user-defined aliases in templates while preserving their original value names for equality comparisons, ensuring that prompts render correctly without breaking logic checks. Class fields are now rendered using their aliases, and media objects are properly serialized with a distinct delimiter to prevent parsing issues in prompts. The migration also includes comprehensive test coverage for enum comparisons, ordering, and media value handling to ensure consistent behavior across different template contexts.
engine/baml-lib/jinja-runtime · high confidence
LSP server rewritten with bounded memory, deadlock detection, and playground telemetry
The LSP server implementation has been replaced with a new architecture that prevents the multi-GB memory blowups and latency regressions seen in previous versions. It introduces a dedicated owner thread for state mutations, bounded outbound message queues to prevent unbounded memory growth, and a background deadlock watchdog that logs parking\_lot deadlocks. Additionally, the server now supports querying local telemetry recordings via SQL, allowing the playground UI to display execution history and run details.
_baml\_language/crates/baml\_lsp\server · high confidence
New BAML type system and expression engine core
The \baml-types\ library has been refactored to introduce a new internal representation for BAML types and expressions. This change adds a comprehensive \BamlValue\ enum to handle runtime values (including primitives, maps, lists, media, and classes) and a new \Expr\ AST that supports advanced expression features like \for\ loops, \instanceof\ checks, and bitwise operators. It also introduces a \Constraint\ system for block-level checks and assertions, and adds a \GeneratorOutputType\ enum to explicitly define supported code generation targets (such as Python Pydantic, TypeScript, Go, and Rust) along with their default client modes.
engine/baml-lib/baml-types · high confidence
New CI script for installing Ubuntu packages
A new shell script, \ci/ubuntu-install-packages\, has been added to the CI configuration. This script ensures that essential build tools (zsh, xz-utils, liblz4-tool, musl-tools, brotli, zstd) and sudo are available in stripped-down Ubuntu environments by automatically installing them if they are missing.
ci · high confidence
New Pydantic 2-based Python SDK generator
The Python SDK code generator has been replaced with a new emitter (\sdkgen\_python\_pydantic2\) that generates Python classes as Pydantic v2 \BaseModel\ subclasses. This change introduces a new internal representation for emitting Python symbols, including classes, enums, type aliases, and functions, and updates the routing and naming logic to produce a structurally correct \baml\_sdk/\ tree. Users will see generated code that leverages Pydantic v2 features, such as native support for recursive type aliases via \typing\_extensions.TypeAliasType\ and improved handling of optional arguments and type annotations.
_baml\_language/sdks/python/rust/sdkgen\_python\pydantic2 · high confidence
New Python-based speedtest benchmark runner with CLI and profiling support
The speedtest tool now uses a Python implementation (replacing the previous Rust-based runner) to execute and compare BAML benchmarks. This adds a CLI with subcommands to run benchmarks (with adaptive or fixed timing), compare baselines, list workloads, and manage saved results. It includes a terminal-based comparison view that highlights statistically significant performance changes and a profiling mode that captures and diffs CPU profiles using samply. The tool also supports both Git and jj version control systems for tagging and identifying benchmark runs. Also in this area: BAML language version bump to 0.23.0 and addition of speedtest benchmarks; JSON API renaming and bound method generic support. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 3 commits (2 fixes) fixing baml\_language.
_baml\language/tools/speedtest · low confidence · unverified
New release platform contract and CFFI export definitions
The release process now relies on a new machine-readable platform contract (\release/platforms.json\) that defines the supported operating systems, architectures, and build configurations for the wrapper, CFFI, Python, Node.js, Java, and C\# artifacts. A new file (\release/bridge-cffi-public-exports.txt\) explicitly lists the CFFI symbols exposed by the runtime, standardizing the public API surface. Additionally, the packaging script has been updated to produce \baml.tar.gz\ instead of \gloo.tar.gz\, reflecting the product name change.
release · high confidence
New static client parsing and configurable HTTP settings for LLM providers
The LLM client library now supports parsing client configurations statically, introducing a unified \UnresolvedClientProperty\ and \ResolvedClientProperty\ system that handles OpenAI, Anthropic, AWS Bedrock, Vertex AI, Google AI, Round Robin, and Fallback strategies. This refactor adds configurable HTTP settings, including connection pooling, timeouts, and proxy support, via a new \HttpConfig\ struct. It also introduces role remapping capabilities, allowing users to map common roles to model-specific ones, and adds specific support for features like Vertex AI authentication chains and AWS Bedrock inference configuration.
engine/baml-lib/llm-client · high confidence
New structured error taxonomy and classification for AI invocations
The AI client surface now uses a closed, typed error hierarchy (\InvokeError\) instead of opaque failures. A new \normalize\ function maps raw infrastructure errors (such as \InvalidArgument\, \ParseError\, \Io\, and JSON serialization issues) into specific, retry-aware classes like \InvalidRequest\, \NetworkFailure\, and \InvalidResponse\. This allows callers to make precise decisions about retry safety (Safe, Unknown, Unsafe) based on the error type, rather than relying on generic exception handling.
_baml\_language/crates/baml\_builtins2/baml\_std/ai/ns\errors · high confidence
New type coercion engine for JSONish deserialization
The JSONish deserializer now uses a dedicated type coercion system to convert parsed JSONish values into BAML types. This new logic handles arrays, maps, unions, literals, and primitives with improved scoring and hinting, allowing the parser to better select the correct union variant and handle streaming contexts more reliably.
engine/baml-lib/jsonish · high confidence
Next.js 15 requirement and Turbopack support for BAML integration
The @boundaryml/nextjs plugin now requires Next.js 15 or higher and adds support for building with Turbopack. The plugin detects the Next.js version to apply the correct configuration: for Next.js 14+, it uses the \serverExternalPackages\ array to externalize BAML native modules, while older versions fall back to the experimental \serverComponentsExternalPackages\. When Turbopack is enabled (via \TURBOPACK=1\), the plugin skips adding custom webpack rules for \.node\ files, ensuring compatibility with the new bundler. The plugin also provides React hooks for streaming BAML function results in Server Actions.
typescript/packages/nextjs-plugin · high confidence
Parser database refactored with new attribute validation and constraint system
The parser database in \engine/baml-lib/parser-database\ has been restructured to introduce a dedicated attribute validation system and support for block-level constraints. This change adds new modules for handling \@alias\, \@description\, and \@skip\ attributes, while introducing \@check\ and \@assert\ attributes that accept Jinja expressions to validate data at parse time. A new \Context\ state machine now manages attribute validation to ensure no attributes are left unprocessed, and a string interner has been added to reduce memory usage. Additionally, the codebase now includes Tarjan's algorithm for detecting recursive cycles in type definitions and improved name validation for reserved identifiers.
engine/baml-lib/parser-database · high confidence
Python SDK bridge re-architected on bex\_engine with new host-callback and media handling
The Python SDK bridge has been rewritten to use the \bex\_engine\ (via \bridge\_cffi\) instead of the legacy \baml-runtime\. This introduces a new process-wide host-value registry for Python callables, enabling robust synchronous and asynchronous callback dispatch that respects the originating Python event loop and context variables. The \BamlRuntime\ class now exposes \initialize\_runtime\ and \initialize\_runtime\_from\_blob\ to manage the singleton engine, while function calls return structured \BamlOutboundResult\ envelopes that decode to \BamlError\ or \BamlPanic\ exceptions. New PyO3 types for media (\Image\, \Video\, \Audio\, \Pdf\) and a \FunctionResult\ wrapper are provided, along with utilities for tracing, invocation context, and unhandled spawn error reporting.
_baml\_language/sdks/python/rust/bridge\python · high confidence
Python client generator overhaul with new runtime and streaming support
The Python code generator has been completely rewritten to use a new CFFI-based runtime bridge, replacing the previous implementation. This change introduces a new client architecture with separate async and sync clients, enhanced streaming capabilities via \BamlStream\ and \BamlSyncStream\, and support for advanced options like \on\_tick\ callbacks, \tags\, and \abort\_controller\. The generated code now includes improved type handling with Pydantic integration, better error handling with \BamlAbortError\, and new tracing/watcher infrastructure. Users will see changes in how they interact with the generated client, including new method signatures and options, though the public API surface remains largely compatible through the \b\ client instance.
engine/generators/languages/python · high confidence
Redesigned TypeScript SDK bridge with BEP-81 invocation and structured error handling
The TypeScript SDK bridge has been rebuilt to support the new BEP-81 invocation ABI, introducing a new \BamlFunctionSpec\ class for introspecting and calling LLM functions, and a \defineFunction\ factory for binding BAML callables with support for generic type parameters (\$types\) and optional arguments. The runtime now manages invocation lifecycles via \ExecutionContext\ and \CallContextBinding\, ensuring proper cleanup of signals and cancellation tokens. Error handling has been standardized with a new hierarchy of \BamlError\ subclasses (e.g., \BamlInvalidArgumentError\, \BamlClientError\, \BamlPanic\) that carry structured details like BAML stack traces and class names. Additionally, the bridge now supports overriding the native library path via the \BAML\_BRIDGE\_PATH\ environment variable and installs a shutdown hook to cleanly terminate the runtime on process exit.
_baml\_language/sdks/typescript/bridge\typescript/dist · high confidence
Redesigned TypeScript SDK bridge with new runtime, invocation, and error handling
The TypeScript SDK bridge has been completely rewritten to support Node, Web, and Workers runtimes. This change introduces a new runtime initialization flow (including \initializeRuntimeFromBlob\ for embedded bytecode), a redesigned invocation system with generic type parameter support (\$types\), and a structured error hierarchy (\BamlError\, \BamlPanic\, etc.). It also adds new capabilities for host-side tracing and value capture, a mechanism to override the native addon path via the \BAML\_BRIDGE\_PATH\ environment variable, and improved type safety for function calls and streaming.
_baml\_language/sdks/typescript/bridge\_typescript/typescript\src · high confidence
Redesigned detail panel and upgraded graph edge routing
The detail panel has been rebuilt to display node information without tabs, showing a compact header with status badges and rendering specific content for LLM, standard, and non-function nodes. A new Execution Log Panel provides a chronological timeline of execution events, including variable updates and node enter/exit states. In the graph view, edge routing has been upgraded to use an A\* search algorithm with Manhattan distance heuristics to find optimal paths that avoid node intersections, replacing the previous layout logic. This new system also supports rounded corners on edges and distinguishes backward or hub connections with dashed lines.
typescript/packages/playground-common/src/features/detail-panel, typescript/packages/playground-common/src/features/graph · high confidence
Refactored CLI downloader with robust download management and platform support
The VS Code extension's CLI download logic has been restructured into a modular \cli-downloader\ component to improve reliability and cross-platform compatibility. The new system introduces exponential backoff to prevent excessive retry attempts during network failures, SHA256 checksum verification to ensure binary integrity, and caching of downloaded CLIs in the \\~/.baml\ directory. It also adds comprehensive platform detection for Windows, macOS, and Linux (including musl/gnu libc differentiation) and supports resolving the CLI from bundled sources, user-configured paths, or remote downloads.
typescript/apps/vscode-ext/src/plugins/language-server-client · high confidence
Regenerated Go CFFI protobuf bindings for the new bridge protocol
The Go SDK's internal CFFI layer has been regenerated to match the updated \baml\_bridge/cffi/v1\ protocol definitions. This update introduces new handle types (such as \HOST\_VALUE\_CALLABLE\, \HOST\_VALUE\_OPAQUE\, and \ADT\_FUNCTION\_SPEC\) and refactors the outbound result envelope to explicitly distinguish between successful values, errors, and panics, ensuring that Go clients correctly interpret structured error and panic data returned from the engine.
_baml\_language/sdks/go/baml\go/internal/cffi · high confidence
Relocate LLM output formatting and SAP parsing to sys\_ops
The \sys\_ops\ crate now hosts the logic for LLM output format rendering and Schema-Aware Parsing (SAP), which were previously located in the deleted \sys\_llm\ crate. This change consolidates the code generation for IO traits and adapters, and ensures that LLM parsing errors are correctly mapped to \LlmClient\ or \InvalidArgument\ BAML error types, preserving the existing error taxonomy for users.
_baml\_language/crates/sys\ops · high confidence
Slimmed AWS SDK fork with comprehensive credential-resolution tests
The \baml\_language/forks\ area now includes a forked \aws-config\ crate (\forked\_aws\_config\) and \forked\_aws\sigv4\ that replace the upstream AWS SDK dependency graph with a slimmed-in-tree implementation. This fork provides only the credential resolution, region resolution, and SigV4 request signing that BAML needs, removing the broader Smithy/\aws-smithy-\\ machinery. To ensure correctness, a full test suite (100 offline tests) and an end-to-end system-test harness (\aws-config-systest\) have been added to verify that every standard AWS authentication form (environment variables, shared profiles, \credential\_process\, SSO, ECS/container endpoints, and EC2 IMDSv2) resolves correctly and produces signatures accepted by real AWS.
_baml\language/forks · high confidence
Standardized development environment and CI configuration
The repository now enforces consistent line endings (LF) for BAML source files, generated clients, and test fixtures via \.gitattributes\ to prevent platform-specific streaming and diff issues. Development tooling is centralized through \.envrc\ (direnv) and \.pre-commit-config.yaml\, which configure \mise\ for tool versioning, \sccache\ with Cloudflare R2 for build acceleration, and pre-commit hooks for formatting and linting. Additionally, a custom \baml\_client\ git merge driver is registered in \.gitconfig\ to handle generated client files, and deployment artifacts are filtered via \.dockerignore\ and \.vercelignore\.
(repo-wide) · high confidence
Swift SDK bridge now supports invoking BAML closures and unified CFFI API
The Swift SDK bridge (CBamlBridge) has been updated to support invoking returned BAML closures across SDKs, allowing Swift applications to handle and execute functions returned by BAML runtimes. This change consolidates the \call\_function\ and \call\_handle\ APIs into a unified interface via the CFFI header (\baml\_cffi.h\), which now defines ABI revision 4. This revision enforces that media values hold content directly rather than file paths, removing file-backed media support and requiring \media\_name\ and \media\_from\_file\_content\ for media handling. The bridge also registers Swift as a supported language in the stable host-language bridge identity and includes stability fixes for error reporting and runtime initialization.
_baml\language/sdks/swift/Sources/CBamlBridge · high confidence
Swift bridge protocol buffer definitions updated
The Swift SDK's protocol buffer client code has been regenerated to align with the latest CFFI bridge schema. This update introduces new handle types for host-owned callables and opaque values, expands the inbound value model to support reflected type definitions and media/prompt AST payloads, and wraps function results in a structured envelope that explicitly distinguishes between successful returns, errors, and panics.
_baml\language/sdks/swift/Sources/BamlBridge/Proto · high confidence
Updated Python integration test client with new streaming and checked-type models
The Python integration test suite's generated client code has been updated to include new \StreamState\ and \Checked\ types, enabling support for streaming outputs and validation checks in the test scenarios. The \stream\_types.py\ file introduces a generic \StreamState\ model to handle partial/streaming responses, while \types.py\ defines the \Checked\ wrapper and associated utility functions. Existing model definitions in the test suite have also been adjusted to reflect these structural changes.
python-integ-tests · high confidence
Updated Rust integration test suite with BAML source map and generator configuration
The Rust integration tests now include a generated \baml\_source\_map.rs\ file that embeds the BAML source definitions (clients, functions, and test cases) directly into the binary, alongside an updated \generators.baml\ configuration file that sets the generator version to 0.226.2 and configures the Rust output directory to \../rust/src\. This change ensures the Rust test environment is synchronized with the latest BAML schema definitions and generator settings.
integ-tests/rust · high confidence
Updated TypeScript CFFI bridge types for new value representations
The TypeScript SDK's CFFI bridge definitions (baml\_cffi.d.ts and baml\_cffi.js) have been regenerated to reflect changes in the underlying protocol buffer schema. The InboundValue message now includes new fields for handling JavaScript number ambiguity (jsNumberValue), type definitions (tyValue, tyDefValue), media values (mediaValue), and prompt ASTs (promptAstValue), alongside existing support for strings, numbers, booleans, lists, maps, classes, enums, handles, and byte arrays. This ensures the TypeScript client correctly serializes and deserializes these expanded value types when communicating with the native runtime.
_baml\_language/sdks/typescript/bridge\_typescript/dist/proto, baml\_language/sdks/typescript/bridge\_typescript/typescript\src/proto · high confidence
WASM runtime refactoring and new LSP type definitions
The WASM engine module has been restructured to improve modularity and enable new capabilities. A new \baml-lsp-types\ crate has been introduced to define shared types for the Language Server Protocol, separating them from the WASM-specific dependencies to avoid build issues in other environments. The WASM runtime itself now includes an \abort\_controller\ to support operation cancellation via JavaScript \AbortSignal\, and a \js\_callback\_bridge\ to securely handle asynchronous credential loading for AWS and GCP providers from the sandboxed WASM environment. Additionally, the runtime now exposes detailed prompt and scope information (including media types and orchestration context) to the frontend, and provides a \format\_document\ function for on-the-fly schema formatting.
engine/baml-schema-wasm · high confidence
Windows build optimization via native sccache wrapper
A new native Rust binary has been added to replace the previous shell script for handling sccache on Windows. This change resolves command-line length limits encountered by certain crates (such as windows-sys) by bypassing the cmd.exe interpreter, which previously restricted argument lengths to approximately 8191 characters. The binary also automatically maps BAML-specific R2 credentials to the AWS environment variables required by sccache, ensuring seamless caching behavior for Rust builds on Windows.
_baml\_language/tools\sccache · high confidence
Fixes
1 commit (1 fix) fixing baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\_archive, baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\_path
A fix in baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\_archive, baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\_path — 1 commit (1 fix), 2 files: “fix(stdlib): augment fs, path, host, archive, toml APIs (\#5457)” (refs \#5457).
_baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\_archive, baml\_language/crates/baml\_builtins2/baml\_std/baml/ns\path · medium confidence · unverified
1 commit (1 fix) fixing baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_alias\_order
A fix in baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_alias\_order — 1 commit (1 fix), 1 file: “fix(python): order type aliases after definitions (\#4256)” (refs \#4256).
_baml\_language/sdk\_tests/fixtures/type\_shapes/baml\_src/ns\_alias\order · medium confidence · unverified
Added empty streaming replay-harness recorder crate
A new Rust library crate \sdk\_test\_llm\_recordings\ has been added to the test harness infrastructure. The crate itself is intentionally empty, serving only as a build target to support the streaming replay-harness recorder logic located in the integration test \tests/recordings.rs\.
_baml\_language/sdk\_tests/harness/llm\recordings · high confidence
Language server now supports BAML files located outside the \`baml\_src\` directory
The language server has been updated to correctly handle \.baml\ files that are not located within a \baml\_src\ directory. Previously, opening such files could cause the server to crash or fail to recognize the project structure. This change introduces new file utility functions (\find\_baml\_src\, \gather\_files\) and robust source file handling (\SourceFile\, \LineIndex\) that allow the server to locate project roots and process files regardless of their specific directory placement, ensuring stable operation for all valid BAML files.
_engine/language\server · high confidence
Python SDK: Generated models now call model\_rebuild() to prevent declaration-order failures
The Python code generator now appends a \model\_rebuild()\ call to every generated Pydantic model (in both \types.py\ and \stream\_types.py\). This ensures that string forward references are resolved after all classes are defined, preventing \pydantic.errors.PydanticUserError\ crashes caused by class declaration order. Recursive models are intentionally excluded from this rebuild to avoid infinite recursion.
python · high confidence
Test coverage
10 commits adding/updating tests in baml\_language/sdks/swift/Tests; 2 commits adding/updating tests in baml\_language/sdks/rust/bridge\_rust/tests/common; 5 commits adding/updating tests in baml\_language/sdk\_tests/specs; 95 commits adding/updating tests in baml\_language/crates/baml\_cli/tests; Add Ruby bridge loader and lifecycle tests; Add host reflection and type inspection fixtures; Added BAML function call fixtures for SDK testing; Added BTEL query and recording benchmark tools; Added C\# bridge verification and conformance probes; Added Python SDK test suite for bridge internals and runtime behavior; Added a web-based UI for visualizing runtime snapshot tests; Added comprehensive test coverage for BAML compiler and runtime behavior; Added comprehensive test suite for the TypeScript bridge; Added generic function and static method edge-case test fixtures; Added incremental compilation testing infrastructure; Added integration tests for LSP protocol and state substrate; Added parser stress test suite for edge cases and large inputs; Added test fixture for AI error handling scenarios; Added test fixture for Go reflection type handling; Added test fixture for class method invocation patterns; Added test fixtures for catalog types, launch context, and trace disabling; Added test fixtures for error handling and cancellation scenarios; Added tests for BAML telemetry query capabilities; Added tests for navigation state integration; C++ SDK test harness and parity test coverage; Compiler2 TIR test suite for type inference, generics, and pattern matching; Expanded Go SDK test coverage for time types and method self-edges; Expanded TypeScript SDK test coverage for callable lifecycles, dispatch, and cancellation; Expanded broken-syntax test coverage for parser diagnostics and language features; Go SDK test suite expands to cover generated code correctness and runtime behavior; Integration tests for compiler2 bytecode emission and runtime ID handling; Introduction of a new test harness for validating code generator consistency; Java SDK parity tests for function calls, generics, and error handling; New BAML standard library for testing with composable runners and testsets; New LLM function test fixtures and streaming replay harness; New host instrumentation audit suite for Python and Node bridges; New streaming replay harness for LLM test recordings; New test harness runner for SDK generator validation; New test utilities for parser diagnostics and incremental parsing; New type-spec test harness and coherence checks for the hir\_ty engine; Swift SDK test suite for function calls, LLM streaming, and type shapes; Type system regression tests for inference, generics, and error handling; Unified test infrastructure with inline snapshots and corpus-wide regression coverage; Updated IDE snapshot tests for BAML language features.
Dependencies
New baml\_language workspace with Rust SDKs and compiler infrastructure
The \baml\_language\ directory now contains a dedicated Rust workspace that consolidates the BAML compiler infrastructure (parser, HIR, type system, VM) and language-specific SDK generators for Python, TypeScript, Go, Java, C\#, Swift, and C++. This change introduces a new \Cargo.lock\ and \Cargo.toml\ configuration, establishing the dependency graph and build structure for these components.
(dependencies) · high confidence
Housekeeping
Engine version bump to 0.20.0-canary.0
The engine's version has been updated to 0.20.0-canary.0. This change is reflected in the \.bumpversion.cfg\ configuration file, which sets the current version and defines the parsing and serialization rules for the version string format (major.minor.patch-pre.prerelease).
engine · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 49 → 49 (+0.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 50 → 58 (+8.0)
- Architecture 44 → 45 (+0.3)
- Maturity 64 → 68 (+3.9)
- Readiness 54 → 48 (-6.6)
- Security 46 → 50 (+3.7)
- Event Sourcing 100 → 100 (+0.0)
- Performance 66 → 59 (-7.1)
Resolved (1058)
- ArrayInitializer::try_print_single_line (cognitive 16) (baml_language/crates/baml_fmt/src/ast/expressions.rs)
- BacktickStringLiteral::flat_parts (cognitive 44) (baml_language/crates/baml_compiler_syntax/src/ast.rs)
- BacktickStringLiteral::flat_parts (cyclomatic 31) (baml_language/crates/baml_compiler_syntax/src/ast.rs)
- BamlPlayground.BamlPlayground (cognitive 22) (typescript2/app-website/playground/BamlPlayground.tsx)
- BamlPlayground.BamlPlayground (cyclomatic 21) (typescript2/app-website/playground/BamlPlayground.tsx)
- BexEngine::landed_kind_admitted (cognitive 18) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::landed_kind_admitted (cyclomatic 24) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::materialize_external_node (cognitive 74) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::materialize_external_node (cyclomatic 60) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::synth_ty_from_value (cognitive 16) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::synth_ty_from_value (cyclomatic 24) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::validate_host_return_schema (cognitive 69) (baml_language/crates/bex_engine/src/conversion.rs)
- BexEngine::validate_host_return_schema (cyclomatic 34) (baml_language/crates/bex_engine/src/conversion.rs)
- BexHeap::collect_young_references (cognitive 45) (baml_language/crates/bex_heap/src/gc.rs)
- BexHeap::collect_young_references (cyclomatic 48) (baml_language/crates/bex_heap/src/gc.rs)
- BexVm::forward_roots (cognitive 30) (baml_language/crates/bex_vm/src/vm.rs)
- BexVm::forward_roots (cyclomatic 21) (baml_language/crates/bex_vm/src/vm.rs)
- BexVm::set_entry_point_with_type_values (cognitive 51) (baml_language/crates/bex_vm/src/vm.rs)
- BexVm::set_entry_point_with_type_values (cyclomatic 34) (baml_language/crates/bex_vm/src/vm.rs)
- BexVm::unwind_exception (cognitive 84) (baml_language/crates/bex_vm/src/vm.rs)
- …and 1038 more
New (1944)
- BamlType.compareTo (cognitive 17) (baml_language/sdks/java/baml_bridge/src/main/java/baml_bridge/BamlType.java)
- BamlType.matchesStructural (cognitive 16) (baml_language/sdks/java/baml_bridge/src/main/java/baml_bridge/BamlType.java)
- BamlType.toString (cyclomatic 38) (baml_language/sdks/java/baml_bridge/src/main/java/baml_bridge/BamlType.java)
- BamlType.toWireTy (cyclomatic 26) (baml_language/sdks/java/baml_bridge/src/main/java/baml_bridge/BamlType.java)
- BamlUnion2._bamlDecode (cognitive 21) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion2._bamlDecode (cyclomatic 16) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion3._bamlDecode (cognitive 30) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion3._bamlDecode (cyclomatic 22) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion4._bamlDecode (cognitive 39) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion4._bamlDecode (cyclomatic 28) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion5._bamlDecode (cognitive 48) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion5._bamlDecode (cyclomatic 34) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion6._bamlDecode (cognitive 57) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion6._bamlDecode (cyclomatic 40) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion7._bamlDecode (cognitive 66) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion7._bamlDecode (cyclomatic 46) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion8._bamlDecode (cognitive 75) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlUnion8._bamlDecode (cyclomatic 52) (baml_language/sdks/swift/Sources/BamlBridge/BamlUnions.swift)
- BamlWireDepth.ty (cognitive 26) (baml_language/sdks/swift/Sources/BamlBridge/Encode.swift)
- BamlWireDepth.ty (cyclomatic 25) (baml_language/sdks/swift/Sources/BamlBridge/Encode.swift)
- …and 1924 more
Changes since last survey
- 153 commits — 127 feature/other, 26 fixes
By area
- baml_language/crates — 53 commits
- typescript2/app-website — 31 commits
- baml_language/sdks — 12 commits
- typescript2/app-beps — 12 commits
- .github/workflows — 11 commits
- .trunk/templates — 5 commits
- baml_language/sdk_tests — 5 commits
- (root) — 4 commits
- baml_language/wrapper_tests — 4 commits
- packaging/github-actions — 3 commits
- baml_language/wrapper — 2 commits
- skills/baml-core — 2 commits
- .github/actions — 1 commit
- baml_language/tools — 1 commit
- engine/baml-runtime — 1 commit
- fern/assets — 1 commit
- scripts/install.ps1 — 1 commit
- tools/versions — 1 commit
- typescript2/app-product-metrics — 1 commit
- typescript2/pkg-grammar — 1 commit
Notable commits
- fix: BEPs: team-only BCS design proposals, bep bcs, and fix bep comments/reply (#5616)
- fix: Fix release docs job and setup-baml for wrapper 0.3 output (#5557)
- fix: Fix span start times, stack trace frames and failed spans' errors (#5605)
- fix: Revert "ci: run the Linux SDK tests on Trunk runners (#5581)" (#5622)
- fix: Website: calm down /adopt and fix what it got wrong (#5584)
- fix: Website: fix the homepage's layout defects on a phone (#5585)
- fix: chore: fix TS SDK tests to drop as coercions for host callbacks (#5538)
- fix: ci: speed up wrapper tests and fix CI artifact and cleanup failures (#5514)
- fix: fix(ci): bootstrap Node before pnpm in engine release containers (#5440)
- fix: fix(compiler): report dead literal arms after a type test on unknown scrutinees (#5655)
- fix: fix(compiler): type union interface members per arm and record the dispatch view (#5632)
- fix: fix(engine): close eMudhra and Brotli security gaps (#5435)
- fix: fix(escape analysis): share objects a finalizer can reach (#5531)
- fix: fix(installer): fall back to plain toolchain use when the help probe fails (#5516)
- fix: fix(parser): better distinguish subtraction from negation (#5439)
- fix: fix(python): make pydantic a runtime dependency of baml_bridge (#5482)
- fix: fix(release): stop requiring BAML wrapper candidates on nightly releases (#5515)
- fix: fix(release): trust Homebrew formula before auditing it (#5546)
- fix: fix(stdlib): augment fs, path, host, archive, toml APIs (#5457)
- fix: fix(stdlib): improve subprocess management API, for the baml wrapper (#5456)
- …and 133 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed
Added bounded contexts (1)
- baml_language/sdks/python
Removed bounded contexts (1)
- bridge_go
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
BoundaryML/baml was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit f8f559fa544d2d69be726d0355de42800c6c8dfc — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.