The only way to get software perfectly tailored to every need you have is to write each line yourself. If you happen to be an immortal with infinite time, infinite money, and infinite patience for maintaining custom code, that might be an option for you. Many mere mortals, however, don't have the brain space to write every single line of code for Wagtail projects, so they rely on packages.
What are packages? The quick answer is that they are applications that add features and functions to a Python programming project. Note, that I said Python there. Wagtail is a part of a broader Python ecosystem, and technically Wagtail is a package that can be installed as a part of a larger Python project, whether that project is an application for locating tasty tacos or an online magazine about the latest trends in rubber bands. Django (the framework Wagtail is based on) is a package as well that has be installed for Wagtail to work.
Feeling confused? Trying thinking of it like this. If your Wagtail application was a factory, then the two largest departments inside that factory would be Wagtail and Django.
These two departments need each other to function, so they're going to be neighbours and they're going to be passing a lot of information back and forth between each other. Other, smaller departments will also be connected to Wagtail or Django. These smaller departments might work only with Wagtail, others might work only with Django, and some might work with both.
These smaller departments are what most developers refer to as "Wagtail packages" or "Django packages". For example, Wagtail includes some SEO features out of the box but usually not all of the features that make marketing teams happy. So many people will install the wagtail-metadata package to add more SEO features to Wagtail. To keep things simple though, I'm just going to refer to all packages as Wagtail packages for the rest of this article. If you care to explore the complexities of project architecture any further, I recommend buying your favorite developer some espresso.
Where to find Wagtail packages
Wagtail packages aren't hard to find. Many are listed right here on the Packages page, and you can find even more packages that are compatible with Wagtail on Django Packages, GitHub, or PyPI. Deciding which of those packages will work best for your project is a little trickier though. Coding experience helps, but it isn't necessary. Anyone who's willing to do some research can identify good packages by answering these five questions:
Is there an up-to-date listing on PyPI?
While PyPI might sound like the name of a cute game about a pie detective when you say it out loud, it's a very critical package repository that supports the Python programming community. Short for Python Package Index, PyPI is a huge collection of packages that can be used for any Python projects, including Wagtail projects.
You don't have to start your search for Wagtail packages in PyPI. Since the index contains over 400K projects that support everything from processing scientific data to user authentication, you might be better off checking the Wagtail.org Packages page, Django Packages or GitHub first. PyPi does have some filters that are useful if you're looking for packages that are compatible with specific versions of Wagtail, including Wagtail 2, Wagtail 3, and Wagtail 4.
BUT, no matter where you find a package, you'll definitely want to check that the PyPI listing for that package is active and up-to-date. If the release date in the upper right corner is older than a year, you should consider other options. I'll talk about why in the next section.
Are there new releases that are less than a year old?
Looking at the release history for a package is the quickest way to help you figure out if a package is being actively maintained. If there haven't been any new releases for over a year, you should consider looking at other packages. There's nothing stopping you from using older packages if you really want to. Just keep in mind that they might not be compatible with the newest version of Wagtail and you might find yourself doing a bunch of extra work to make the package work (which can defeat the purpose of using a package in the first place).
The easiest place to check the release history is on PyPI. Let's use the Wagtail PiPy page as an example. On the left side, you'll notice there's a menu item called "Release history". If you click on it, you'll see a timeline of package releases. Scroll through to check that there have been recent releases and to see how often the maintainers publish new releases. If there aren't any super long gaps between releases, that's a good sign that the package is being actively supported and improved on a regular basis.
Is there up-to-date documentation available?
Unless you enjoy the pain of reverse engineering, there's not much point in installing a package that doesn't have instructions on how to use it. If you're using a package that has code provided in GitHub, many authors include the documentation as a part of the README file. Some package authors will have a separate site for documentation. On PyPI, you can often find the documentation through the "Homepage" link or a specific "Documentation" link. Make sure the documentation matches the latest package release.
Are the maintainers active and responsive?
Maintainers are very busy people, yet they also tend to be very generous with their time. A lot of them volunteer their time to support packages, and not all of them have an organisation paying them for that time. That being said, you should have some way to reach them if you or one of your developers are having trouble with their package. First, check to see if they offer support for their package and how they offer it. Some package authors will tell you to post support requests in their GitHub repositories, others will ask that you use StackOverflow, and some will even offer their own forums or chat communities.
Once you know where support requests are supposed to go, have a look at the questions that other people asked. See how many questions were answered and how quickly they were answered. Again, remember that most package maintainers are volunteers. They might take days or weeks to answer questions because they are supporting the package as a hobby or side project. The key thing to check for is that they're responding to questions. If their Issues queue or forum is just a long list of questions with no answers, that's a sign that the package might not be your best choice and you should keep looking.
Are there opportunities to sponsor the package?
Some maintainers might offer a quicker turnaround for support if you're willing to sponsor their work or pay them for their time. Check their GitHub profiles or their personal webpages to see if they offer opportunities for premium support or sponsorship. Even if they don't have an official support offering, they will probably be more invested in responding to your questions if you're supporting them.
If you're like most people or organisations, you probably don't have an unlimited budget. So think about what packages are absolutely critical for your application to work and prioritize sponsoring them. For example, the tasty taco application I mention earlier might sponsor a package that helps them process GPS data. The online rubber band magazine (which my imagination has named Elastizine) might choose to sponsor Django or Wagtail since content management is more important to them.
By the way, if you are ever inclined to sponsor Wagtail, we currently offer opportunities for organisations to sponsor new features or packages. If you can't find a package for a feature you really need for Wagtail, go ahead and reach out to us. We'd love to help.
What if I want to use a package that doesn't meet these criteria?
There are almost certainly going to be packages out there that work really well even though they don't meet these criteria. These questions are just guidelines after all, and there's no way to account for the specific needs of every project. One thing to keep in mind is that the package might work really well for you right now and then break spectacularly when you update to a new version of Wagtail. It might be worth asking other people in the Wagtail Slack community if they have any experience using the package.
Happy package hunting!
I hope these questions provide you with some good criteria for picking out Wagtail packages. If you feel like this is too much work and just want someone to build a package for you, consider sponsoring a Wagtail package, reach out to one of the many fine agencies that work with Wagtail, or pitch your idea to the community. No doubt, you'll find a great collaborator to work with.
Other Package Resources
Here's a quick list of other resources you might find helpful for finding packages:
- Django packages Wagtail Grid: A grid listing Django packages for Wagtail
- 10 Most-Used Django packages: Top ten packages used for Django (as measured by downloads)
- Python readiness: A website looking at how much support is provided for the most popular packages for each version of Python
- Awesome Wagtail: A curated collection of packages and other awesome things for Wagtail
- Awesome Django: A curated collection of packages and other awesome things for Django