Wild's benchmark section introduces a Chromium run and then prints no numbers
A very fast linker for Linux. Rust (Cargo) You can use one of the options mentioned above in ~/.cargo/config.toml: Or: CMake CMake 4.4 or later supports Wild directly when used with Clang or GCC 16 or later.
At a glance
- What is it?
- Wild is a linker written in Rust, aimed at the initial link rather than at incremental relinking, and it supports five Linux architectures. The repository is unusually well documented for a project of its size. It also has a benchmark section that promises a result and then stops mid-sentence.
- Who is it for?
- The linker fits a Rust or C project on Linux that links often enough for the initial link to be felt, and it fits a developer who wants a linker they can read. It does not fit anyone expecting incremental relinking, which the page names as the goal and then says is not implemented.
- Can I use it commercially?
- Yes. Apache-2.0 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?
- Yes. The repository received new commits within the last day.
- 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.
Star history
- wild-linker/wild4,122 ★ · +302
| Repository | 2026-08-04 | 2026-11-15 |
|---|---|---|
| wild-linker/wild | 3.8k | 4.1k |
302 Stars in the last 103 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The benchmark section promises a Chromium result and then stops
The benchmarks section has three parts. A statement of what is being optimised for. A list of three machines. And one worked example.
The worked example is introduced with the words: for example, linking Chromium with a particular kind of relocation on the Ryzen system. Then nothing follows. No time, no comparison, no link.
So the only concrete performance claim on the page is a machine list and a sentence that ends in a colon. The three machines are named precisely, a sixteen-core desktop part with thirty-two threads, a 2020-era four-core laptop with eight threads, and a single-board computer from 2023. Each has its own results file in a directory beside the readme, which is where a reader has to go for the numbers.
Choosing a desktop part, a laptop from six years ago and a small board is a sensible spread: the laptop is the machine most people link on, and the small board is the machine where a slow linker is felt most. The failure is not the choice of machines. It is that the one number the page offers to quote has been replaced by a placeholder.
The stated goal in that paragraph is worth keeping separate from the headline, though: being fast when linking is not incremental, and being fast on the first link when incremental linking is enabled.
Incremental linking is the goal and the second sentence says it is not there
The opening is two sentences and the second one is a disclaimer.
The first says the goal is to be very fast for iterative development. The second says the plan is eventually to make it incremental, that this is not implemented, and that the linker is already fairly fast without it.
That is an unusual opening for a project page, and a useful one. The name of the project and the shape of the README both promise incremental relinking, and this is where the page says it does not exist yet.
It comes back a third time in the list of things the project is looking ahead to, where incremental linking is the first item. So the page mentions it in the summary, in the benchmarks section and in the roadmap, and in all three places it is a future feature.
What a reader gets instead is a fast full link. That is a real and useful thing, and it is what the benchmark machines are measuring. It is also a different thing from what the project's own description leads with, and the difference between those two things is the sentence above.
Five architectures, one of them initial, and a roadmap that mixes machines with file formats
The supported list has five entries and they are all Linux.
Two are the obvious ones. Three are the interesting ones: a RISC-V profile named for a specific general-purpose extension set, a Chinese instruction set architecture, and 64-bit Power, which is the only one carrying a qualifier saying support is initial.
Supporting five architectures is a statement about how portable a linker is, and it is a claim about the output as much as the input, because a linker has to emit object files for the target it is producing.
Which is where the second list gets confusing. The things the project is looking ahead to are incremental linking, support for another object format, support for a browser-targeted output format, and Windows support.
Two of those are file formats and two are platforms, in one four-item list, with no indication whether the format work or the platform work is the near-term one. A reader who wants to know whether the browser output is a month away or a year away gets nothing here.
Two licence files at the root and one value in the metadata
The licence section offers a choice. You may use it under the Apache License version 2, or under the MIT licence, at your option.
The root carries a file for each. It also carries a directory of third-party licence texts, and a configuration file for tracking that every file has a licence header, which is the compliance mechanism for a project with this many vendored pieces.
Contributions are covered explicitly: unless you say otherwise, anything you submit for inclusion is dual licensed on the same terms, with no additional conditions. That is the standard formulation and it is worth having in writing, because a project with two licences and external contributors otherwise spends its review time on licence questions.
The repository's metadata records a single licence value, and it names one of the two options rather than the disjunction. So a tool that reads the licence from the package metadata sees a choice the project did not make, and the tree is the place to look for the real answer.
Every dependency has its default features switched off
The workspace manifest has a comment explaining its version policy before it has a single dependency in it, and the policy is unusually careful. The listed versions are minimum supported versions, and they should only go up when there is a new major version the project would not otherwise get, or when a listed minimum has stopped being correct because a feature it uses no longer exists in it. In the second case the guidance is to raise it to the lowest version they can support.
Then the dependencies themselves, and the pattern is consistent: every one of them turns off default features. A general-purpose error library, a byte-size crate, a hash library with its multi-threading feature added back explicitly, a colour library, and a build-time compiler driver all appear with default features off, and the argument-parsing library re-enables four named features by hand.
That is the trade that makes a fast linker possible, written out in the manifest: nothing arrives that the project did not ask for.
The toolchain is pinned too. The manifest declares a minimum Rust version of 1.98 and an edition of 2024, and there is a toolchain file at the root for contributors to match.
The Nix recipe calls a path the repository root does not contain
Six install routes are documented and five of them are one line each.
A tarball from the releases page that you unpack and copy onto your path. A Rust binary installer. A Homebrew formula. A locked install of the published crate. And a locked install from the git head, which is the only one that names both the crate and the binary:
cargo install --locked --bin wild --git https://github.com/wild-linker/wild.git wild-linkerThe crate is called one thing and the binary another, and this line is the only place both appear together, which is exactly what a reader needs when the four other routes use one or the other.
The sixth route is a Nix expression. It takes the standard derivation environment, wraps it with a helper that selects this linker, and then calls a path called package in the current directory with that environment passed in.
The repository root does not contain a directory or file called package. What it contains is a default expression, a flake, a Nix lock file, a nix directory and a document about packaging. So the snippet works from inside the packaging directory and not from the root, which the page does not say.
Editor configuration for two editors and six tool configs at the root
The root is where a project's working arrangements live, and this one documents them.
There are directories for two editors, one for a modal terminal editor and one for a newer editor, so both are configured in the repository rather than in each developer's setup. There is a spell checker configuration whose file name is itself a typo, which is the joke the tool exists for.
Then the formatting and policy layer: a YAML formatter configuration stored as a bare file with no extension, a TOML formatter configuration, a dependency policy configuration, a licensing configuration, and a lint suppression file for unsafe operations. A Rust source formatting configuration and a toolchain pin sit beside them.
Four more documents sit in the same place, and they are process rather than code: a design document, a governance document, a packaging guide and a release guide. Alongside a changelog and a contributing guide, that is a repository documenting how it is built, how it is packaged and how it is released, which is more than most projects of this size publish.
The test configuration also comes in two forms, a sample file for local use and a separate file for continuous integration, so the two configurations cannot drift into behaving differently.
Editorial conclusion
The linker fits a Rust or C project on Linux that links often enough for the initial link to be felt, and it fits a developer who wants a linker they can read. It does not fit anyone expecting incremental relinking, which the page names as the goal and then says is not implemented. Check three things before switching a build over. Whether your architecture is on the support list, and whether it is marked as initial. Whether your linker script uses anything the support document says is unsupported. And what the build system needs, because CMake has a version requirement and a compiler requirement and the repository's own description field is a broken fragment of the usage section rather than a sentence.
Frequently asked questions
What is the Wild linker?
A linker written in Rust with the goal of being very fast for iterative development. The page says the plan is to make it incremental, that this is not implemented yet, and that it is already fairly fast without incremental linking.
Which platforms does Wild support?
Five architectures on Linux: x86-64, AArch64, RISC-V with a specific profile, LoongArch64 and 64-bit Power, the last of which is marked as initial support. Another object format, a browser-targeted output and Windows support are all listed as future work.
How do I install the Wild linker?
Five routes: a tarball from the releases page copied onto your path, a Rust binary installer, a Homebrew formula, a locked install of the published crate, or a locked install from the git head, which names both the crate and the binary. There is also a Nix expression using a helper derivation that selects this linker.
Which licence is Wild released under?
Either of two, at your option: the Apache License version 2 or the MIT licence, with a file for each at the repository root. Contributions are dual licensed on the same terms unless the contributor states otherwise.
Does Wild do incremental linking?
Not yet. The opening paragraph says making it incremental is the plan and that it is not implemented, and incremental linking is the first item on the list of things the project is looking ahead to.
Official sources
Where developers are discussing it
Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.
- Wild Version 0.11.0 ReleasedHacker News · Oct 24, 2026 · 1 points · 0 comments
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.
[](https://hysenlabs.com/projects/wild-linker-wild)Star history chart for your README
[](https://hysenlabs.com/projects/wild-linker-wild)Was this useful?