baml

We are working on making our programming language BAML turing-complete. https://github.com/boundaryml/baml It is a language that is embeddable in other programming languages, with the type system similar to typescript, and a runtime that is similar to Go. People use it currently for structured outputs with llms but soon we will support orchestration and more. We are letting some users have an early access preview! Let me know if you are interested in hacking with it!

Shout-out to BAML [1], which flies under the radar and imo is underrated for getting structured output out of any LLM. JSON schema is okay so long as it's generated for you, but I'd rather write something human readable and debuggable. 1. https://github.com/BoundaryML/baml

Boundary (YC W23) | Software engineer (compilers) | Seattle, USA (in person) | Full-time We are building a new programming language (BAML) to build AI agents -- the "typescript" for LLMs. We are open source: https://github.com/BoundaryML/baml A big part of this language is all the tooling around visualizing non-deterministic code, visualizing code, and getting great observability (e.g. our language has type information at runtime unlike TS). We are looking for engineers with experience with Rust, programming languages, and/or compilers. Any amount of experience is fine. To apply: send an email to aaron@boundaryml.com with your resume and mention you came from HN

Love the concept, I saw similar ideas in BAML [1], what do you think are the differences and advantages of Pipelex over it? [1]: https://github.com/boundaryml/baml

You may also want to check out BAML https://github.com/BoundaryML/baml - a DSL for prompt templates that are literally treated like functions. the prompt.yaml format (which this project uses) suffers from the fact that it doesn't address the structured outputs problem. Writing schemas in yaml/xml is insanely painful. But BAML just feels like writing typescript types. I'm one of the developers!

Have you tried BAML? https://github.com/BoundaryML/baml

We're making a prompting DSL (BAML https://github.com/BoundaryML/baml) and what we've found is that all the syntax rules can easily be encoded into a Cursor Rules file, which we find LLMs can follow nicely. DSLs are simple by nature so there's not too many rules to define. Here's the cursor rules file we give folks: gist.github.com/aaronvg/b4f590f59b13dcfd79721239128ec208

I've been using using [BAML](https://github.com/boundaryml/baml) to do this, and it works really well. Lets you have multiple different fallback and retry policies, and returns strongly typed outputs from LLMs.

Thanks. We use a minimal schema[1] to prompt the LLM under the hood. We were inspired by BAML [2]. Then the output is wrangled with a converter and ajv [3]. [1] https://github.com/inferablehq/l1m/blob/main/api/src/schema.... [2] https://github.com/boundaryml/baml [3] https://ajv.js.org

Super cool! We at BAML had been thinking about doing something like this for our ecosystem as well - we’d love to add BAML models to this repo! If you haven’t heard of us, we provide a language and runtime that enable defining your schemas in a simpler syntax, and allow usage with _any_ model, not just those that implement tool calling or json mode, by by relying on schema-aligned parsing. Check it out! https://github.com/BoundaryML/baml

This is our interactive playground that uses our framework (BAML https://github.com/BoundaryML/baml) to do structured outputs with R1, without the use of tool-calling APIs or fine-tuning required. We have a more fleshed out playground at https://promptfiddle.com as well. BAML is a DSL for prompts, where prompts are modeled as functions. Our compiler transforms your LLM function declaration into the relevant API call, and will also parse the output for you. We serialize using "type definitions" instead of using json schemas, since they are more efficient and easier to understand for models. We talk more about why here: https://www.boundaryml.com/blog/type-definition-prompting-ba... We ran the Berkeley Function Calling Benchmark some months ago on our approach and achieved really good results https://www.boundaryml.com/blog/sota-function-ca

For structured output from anywhere I'm finding https://github.com/BoundaryML/baml good. It's more accurate than gpt-04-mini will do on its own, and any of the other JSON schema approaches I've tried.

I found it interesting how DSPy created the Signatures concept: https://dspy.ai/learn/programming/signatures/ We took this kind of concept all the way to making a DSL called BAML, where prompts look like literal functions, with input and output types. Playground link here https://www.promptfiddle.com/ https://github.com/BoundaryML/baml (tried pasting code but the formatting is completely off here, sorry). We think we could run some optimizers on this as well in the future! We'll definitely use DSPy as inspiration!