How to Take Over an Abandoned Haskell Package on Hackage
Your build broke because a library you depend on has not seen a release in three years, and the open pull request that fixes it has been sitting there since GHC 9.4.

Your build broke because a library you depend on has not seen a release in three years, and the open pull request that fixes it has been sitting there since GHC 9.4. You could patch it locally forever, or you could take over the abandoned Haskell package and fix it for everyone who hits the same wall. This guide covers the second path, step by step, including the parts that take longer than people expect.
I have watched a few of these handovers from the maintainer side and the newcomer side. The process is not complicated, but it is slow by design, and the people who get frustrated are usually the ones who expected a week instead of a month.
How to tell an abandoned Haskell package from a quiet one
A package with no commits for a year is not automatically abandoned. Plenty of small libraries are simply finished. A parser for a fixed file format or a tiny wrapper around a stable C API might need nothing more than a version bound bump every couple of GHC releases.
The signals that actually matter are these:
- It fails to build with the last two GHC releases and nobody has responded to the issue.
- Pull requests with working fixes have been open for six months or more without a comment.
- Upper bounds on base or other core packages block it from current Stackage snapshots.
- The maintainer's listed email bounces, or their public activity stopped around the same time as the repository.
- Other users have already asked "is this still maintained?" in the issue tracker.
If you see three or more of those, you are probably looking at a package that needs a new owner. If you see only one, open an issue or a pull request first and give the maintainer a fair chance. A lot of "abandoned" packages turn out to have a maintainer who just needed a friendly nudge and a ready-to-merge patch.
Contact the current maintainer first, and do it properly
The Hackage takeover process starts with you trying to reach the person who owns the package now. Skipping this step is the fastest way to get your request refused by the Hackage trustees, and it is also just rude.
Send an email to the address on the package's Hackage page. Keep it short and specific. Something like this works well:
Hi, I use your package in two production services and it no longer builds with GHC 9.8. I have a branch that fixes the build and relaxes the bounds on base and text. Would you be open to adding me as a co-maintainer on Hackage, or would you prefer I take it over entirely? I am happy to keep the existing API stable.
Then do the same thing in public. Open an issue on the repository titled something like "Offer to help maintain" and link to your branch. The public issue matters because it creates a record that you tried, with a date on it, which the trustees will look at later.
Wait at least two weeks. I usually recommend four if the package has many reverse dependencies, since people take holidays and some maintainers only check email once a month. During that time, keep your fixed fork building in CI so you can show it works. If you need a template for that, the setup in our guide to CI for an open source Haskell library covers the GHC version matrix you will want.
Post a public notice in the community
If the maintainer does not answer, the next step is a public announcement. Post on the Haskell Discourse in the Hackage or libraries category, and say plainly what you want: you intend to request maintainership of a named package, you emailed the maintainer on a given date, and you opened an issue on another date.
This step exists for a reason. Sometimes another person is already halfway through the same takeover. Sometimes the original maintainer reads Discourse but not their old email. And sometimes a community member knows that the author handed the project to a colleague who never updated the Hackage metadata. Give this notice another two weeks.
If you want background on how these social norms formed, how the Haskell community builds and maintains its packages explains why so much of the ecosystem runs on trust rather than formal rules.
Ask the Hackage trustees to add you
Once a month or so has passed with no response, email the Hackage trustees and administrators. Include:
- The package name and a link to its Hackage page.
- The dates you emailed the maintainer and opened the repository issue.
- A link to your Discourse post.
- Your Hackage username.
- A short statement of what you plan to do, for example "release a build fix for GHC 9.8 and 9.10, no API changes."
The trustees will check your evidence and, if it holds up, add you to the package's maintainer group. In my experience the whole thing takes four to eight weeks from first email to upload rights. That sounds long, but think about the alternative: a system where anyone could seize a popular package after a few quiet days would be a gift to anyone wanting to slip malicious code into thousands of builds.
Why forking under a new name is often the wrong advice
A common answer on forums is "just fork it and publish as foo-ng or foo2." It feels faster, and you control everything from day one. I think this is usually a mistake for libraries with real users.
Here is the problem. Every downstream package keeps depending on the old name. Stackage keeps the old name in its snapshots until it is dropped for failing to build, and then it vanishes for everyone, including people who never heard of your fork. Users searching Hackage find two nearly identical packages with no clear signal about which one is alive. You end up maintaining a fork that only a fraction of users ever switch to, while the broken original keeps collecting bug reports.
Fork under a new name only when you plan to change the API in ways the original users would not accept, or when the original maintainer explicitly refuses a handover. Otherwise, take over the existing name. It is a month of waiting in exchange for years of not splitting the ecosystem.
The co-maintainer middle ground
If the original author responds but has no time, ask for co-maintainer rights instead of full ownership. They stay listed, you do the releases, and nobody has to feel pushed out. Many long lived Haskell libraries run exactly this way, with two or three people on the maintainer list and one doing most of the work in any given year.
Your first release after a takeover
Your first upload sets the tone, so make it boring. Do not rename modules, reorganise the export list, or switch the test framework in the same release that fixes the build.
- Bump only the minor or patch version if the public API is unchanged. PVP versioning for library maintainers explains which number to change and why.
- Relax upper bounds to cover current GHC and core library versions, then test against the oldest bounds you claim to support.
- Merge the long ignored pull requests that are safe, and credit their authors in the changelog by name.
- Write a changelog entry that says you are the new maintainer and how to reach you.
- Upload a package candidate first, check that the documentation builds, then publish.
After that, set up a predictable rhythm. A release within a month of each new GHC version is plenty for most small libraries. The people depending on you mostly want to know that someone is watching.
Frequently asked questions
How long does it take to take over an abandoned Haskell package?
Plan for four to eight weeks. That covers roughly two to four weeks waiting for the original maintainer, about two weeks for the public Discourse notice, and a few days for the trustees to review. Rushing any step usually means starting over.
Can I take over a Hackage package if the maintainer says no?
No. If the current maintainer answers and declines, the trustees will respect that. Your options are to keep contributing patches upstream or to publish a fork under a different name with a clear explanation of how it differs.
Do I need to be an experienced Haskell developer to maintain a package?
You need to be able to build it, run its tests, and understand the changes you merge. Many maintainers started with a small library close to their own work. If you are newer to the ecosystem, contributing a few fixes elsewhere first, as described in our guide to a first open source contribution, builds the habits that make maintenance easier.
More in Open Source
Open Source
How to Review a Pull Request on a Haskell Project
A contributor sent a 38 line patch to a logging package I help maintain.
Open Source
How to Deprecate a Haskell Package Without Breaking Users
I retired a small Haskell package in 2023 and did it in exactly the wrong order.
Open Source
How to Vet a Haskell Dependency Before You Add It
A student in my second year class added a JSON library to her project because it was the first result she found and the README...