Open-source project
weld-project/weld avatar
weld-project/weld

weld: a runtime whose last release is from 2020 and whose build needs LLVM 6

High-performance runtime for data analytics applications

3,012 stars253 forksRustBSD-3-Clause

At a glance

What is it?
Weld is a language and a runtime for data-intensive applications, built on the observation that combining fast functions from different libraries is slow because of the data movement between them rather than the work inside them. It answers that with a shared intermediate representation and a lazy evaluation strategy. What the repository shows is a project whose newest release is from February 2020, whose branch has moved since, and whose build instructions are pinned to a compiler toolchain from 2018.
Who is it for?
Read Weld as a research result rather than a dependency. The idea is sound and still the right idea: if your pipeline spends its time moving arrays between functions that were each written to be fast alone, then optimising across the boundaries is where the order of magnitude is, and a shared intermediate representation is how you get a compiler to see those boundaries.
Can I use it commercially?
Yes. BSD-3-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 7 months ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • weld-project/weld3,012 ★ · +6
Star history
Repository2026-09-112026-11-15
weld-project/weld3k3k

6 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Six years of commits sit on top of a release line that stopped in 2020

Put two dates next to each other and the state of the project is clear. The newest release on the repository is a zero point four release from February 2020, preceded by two zero point three tags published within minutes of each other one evening in August 2019. The default branch was pushed in April 2026. So there are roughly six years of work above a release line that stopped three years before that, and the version is still below one. The page offers no explanation, no roadmap and nothing that maps the commits to a release. That matters more here than it would for a library, because this is a compiler-shaped project where a version number is the only quick signal of whether an optimiser has changed behaviour. If you are evaluating it, the tag list tells you nothing useful and the source is the only thing worth reading. The repository also carries a contributing file, so at least the entry requirements for reading it are documented.

The premise is that data movement, not arithmetic, is what is slow

The argument is made in one paragraph and it is the whole idea. Modern analytics applications build workflows by combining functions from different libraries and frameworks. Each of those functions can be fast in isolation, and yet the workflow as a whole runs an order of magnitude below what the hardware can do, because data moves across the boundaries between functions constantly and none of those libraries knows what the neighbouring one is about to do. The response has two halves. Express the core computations in libraries using a common intermediate representation, so that there is something for an optimiser to see across library and framework boundaries. And build up the computation for the entire workflow lazily, so it is optimised and evaluated only when a result is actually needed. That is a compiler's answer to a library-boundary problem, which is why the project ships a language and not only a runtime, and why the documentation leads with the syntax of that intermediate representation.

Building it requires a compiler toolchain from 2018

The requirements line is short: the latest stable Rust, and version six point zero of the LLVM toolchain with its C++ front end. Everything else on the page follows from that one number. On macOS the instructions install a versioned formula for that major through a package manager and then symlink its configuration tool into a system directory, because the dependencies look that tool up on the path; they tell you to check the reported version afterwards and expect a six point zero series. On Linux the instructions are given for two distribution releases from the middle of the last decade, add a signing key with a command that current package tooling has removed, and for the older of the two releases pull a compiler backport from a third-party repository because the standard library shipped there is too old. A compression library is also required. So the build recipe is pinned to an ecosystem generation rather than to a platform, and it is a document to be adapted rather than followed.

One instruction in the Linux recipe no longer exists

Both Linux blocks start the same way: fetch a key file over plain HTTP and pipe it into an add-key command. That command was deprecated across the major package tools and has since been removed, so the documented path cannot be run verbatim on a current release. Neither block mentions the package you would need for the repository-adding command they use two lines later, so even a reader who knows to substitute a modern equivalent for the key step is left to work out one more prerequisite. And the two releases the instructions cover are both out of support, so nobody has a current system to test the recipe on. This is the entire installation story rather than an aside, because without a working configuration tool on the path the build stops at its first step. The macOS route is friendlier, since a package manager can still install the old formula, but the versioned formulas it needs are themselves deprecated.

Two shared libraries come out, and the Python side is outside the workspace

The build produces two dynamically linked libraries, one for the compiler side and one for the runtime, with the platform's own extension. With the toolchain in place, the build itself is four lines, because the workspace does the work:

bash
git clone https://www.github.com/weld-project/weld
cd weld/
export WELD_HOME=`pwd`
cargo build --release

That environment variable is not incidental, as the Python section later shows. The Rust workspace lists four members: the core, the C interface, the interactive tool, and a small crate whose only job is generating headers for the C interface, which is the kind of component that saves you from a hand-maintained header drifting out of date. A fifth crate, the Python binding, is explicitly excluded from the workspace. That exclusion is not cosmetic. The root build command does not build the Python side, which is why the Python tool carries its own documentation, its own directory and its own instructions, and why running it needs that same variable set so it can locate its own native library at run time. If your plan involves the Python bindings, the mental model has to be two build systems rather than one, and the workspace manifest is where you learn that.

Four documents, and the tutorial asks you to write a vector library

The documentation directory is described in four bullets and one of them is a better choice than the other three. There is a document for the syntax of the intermediate representation, which is the thing you must understand to write anything at all. There is one for the low-level C interface, for interfacing with the system from something other than Rust. There is an overview of the Python API. And then there is a tutorial for building a small vector library using the system, which teaches the model by having you implement something real rather than by walking through a sample you are meant to admire. There is also a document for the command line tools, which are built automatically alongside the main repository and include an interactive tool for inspecting and debugging programs. Given that this runtime evaluates lazily, that interactive tool is the component you will actually live in when a generated computation does not do what you expected.

A university mailing list and a build badge from a retired service

The discussion links are a Google Group and a mailing list at a university domain, which places the project in a specific institution and a specific era of research tooling, and it is the sort of provenance that is genuinely useful to know about a compiler project. The build badge points at the legacy domain of a continuous integration service, and the repository carries that service's configuration directory as well as its configuration file, alongside a cargo configuration directory of its own. None of that is a criticism, and for a project of this vintage it is entirely coherent. It does mean that every signal a reader normally trusts is historical: the newest release is six years old, the badge points at a service most projects moved away from years ago, and the compiler toolchain the build needs is two major generations behind the one named in the requirements. Read the source, not the metadata. The project is permissively licensed and the source tree is laid out by component, so that much is easy.

Editorial conclusion

Read Weld as a research result rather than a dependency. The idea is sound and still the right idea: if your pipeline spends its time moving arrays between functions that were each written to be fast alone, then optimising across the boundaries is where the order of magnitude is, and a shared intermediate representation is how you get a compiler to see those boundaries. Before you invest, check three things. Whether the branch still builds against a current Rust toolchain, because the instructions ask for a compiler from 2018 and the newest release is six years old, so the recipe is a historical document. Whether the Python side is on your path at all, because it sits outside the build workspace and needs an environment variable at run time. And whether the interactive inspection tool is enough on its own for your debugging, since a lazily evaluated computation is exactly the kind of thing you want to be able to look inside. The default branch was last pushed on 2026-04-13.

Frequently asked questions

What are the three types of weld?

Not a question this repository answers, because nothing here is about joining metal. Weld here is a language and a runtime for data-intensive applications: it expresses the core computations of a workflow in a shared intermediate representation so an optimiser can work across library and framework boundaries, then builds the whole computation lazily and evaluates it only when a result is needed.

How strong is a projection weld?

The repository contains nothing about physical joining of any kind, so there is no material here to answer it with. The project's subject is computation: a pipeline that chains fast functions from different libraries is slow overall because of the data moved between them, and this is a system designed to remove that movement by optimising the whole workflow at once.

Why do welders drink milk after welding?

Unrelated to anything in this repository, which has no welding in it at all. If you were looking for the project rather than the process, the name refers to a runtime and a language for analytics workloads, its discussion happens on a forum and a mailing list at a university address, and its documentation site is linked from the readme.

Do welders make $100 an hour?

The page makes no claim about anyone's income, and it is not about that industry. What it does contain is a build recipe, four documentation files, a Python binding that sits outside the build workspace, and a project whose newest release was published in February 2020 while its default branch was pushed in April 2026.

Official sources

  1. License: BSD-3-Clause
  2. Project website
  3. README
  4. Releases
  5. weld-project/weld on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/weld-project-weld.svg)](https://hysenlabs.com/projects/weld-project-weld)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/weld-project-weld.svg)](https://hysenlabs.com/projects/weld-project-weld)

Was this useful?