The Quilt Project

This is Quilt

Tue, 20 Apr 2021 09:00:00 GMT

Why the Fork?

While the Fabric Project has made significant progress towards an open and advanced mod loader, it has recently slowed down in technical innovation and failed to address several organizational issues. There are a number of changes the Quilt Project will put into place in the future to differentiate ourselves:

Governmental Structure — Quilt’s organizational structure has been designed with openness in mind; no one person holds all the keys.
Separation of Concerns — Those in charge of technical concerns should not be making important community decisions, and vice versa. Quilt’s teams each control a very specific aspect of the project.
Quilt Loader Plugins — Will allow other parties to change mod loading behavior in new and exciting ways.
Dependency Downloading — Users will no longer have to download every single dependency for each of their mods.
Cleaner Bytecode Modifications — A safe, deterministic alternative to “Mixin” or modifying bytecode by hand.
Faster Iteration & Experimentation — The Quilt project aims to fail fast. We would rather try something and fix it then spend countless months debating whether to move forward with it in the first place.

Important Documents and RFCs

Quilt makes use of a Request for Comment system to drive major organizational changes. The RFCs are designed to make clear what changes are on the horizon, allow for comment from the community and as a maintained location for how specific parts of The Quilt Project work (eg Governance).

You can view these documents (accepted and not) via our GitHub Repository; please use this space to submit new RFCs and comment on currently open ones.

The process of RFCs is outlined in RFC-0001.

Who is involved?

To view an approximate membership, our GitHub organization is a good starting place. This list is not exhaustive as it may not include members who are part of the community team.

Can I mod on Fabric and Quilt?

Fabric mods will be able to run on Quilt initially. There may be a point in the future where this is no longer possible.

I have more questions!

We have written a FAQ which hopes to provide answers to some common questions. If something is not covered there, please ask on our Discord.

Quilt September Update

Sun, 19 Sep 2021 15:00:00 GMT

Clean Room RFC-33

RFC-33 has been merged. This RFC changes how Quilt is dealing with other mappings (such as MojMap, MCP and Yarn).

Key Take-Aways:

Quilt’s fork of Yarn will be renamed to “Quilt Mappings” (QM)
All restrictions on referencing mappings projects (other than Quilt Mappings) within Quilt’s community and development spaces will be lifted

The reasoning, possible outcomes, drawbacks and smaller changes are outlined further in the RFC document.

Quilt Mappings

As noted above, Quilt Mappings (QM) exist and are open to contributions.

Quilt Standard Library (QSL)

The Quilt Standard Library (Quilt’s separation of the current Fabric API into distinct modules — see RFC-9), now has the resource loader and base (for events).

We are looking for help testing the resource loader. This can be done by using the snapshot maven repo with org.quiltmc.qsl.core:resource-loader:1.0.0-SNAPSHOT.

QSL is seeing new additions on top of the reorganization into modules.

Quilt Mod JSON

The Quilt Mod JSON has now been mostly implemented. The design of this is outlined in RFC-2.

The majority of the work left is smooth out issues in the loader.

QuiltFlower

QuiltFlower (Quilt’s Fork/Maintained version of FernFlower/ForgeFlower) has seen some smaller changes.

These changes should make de-complied code more readable. An example of this can be seen in the following images:

Output produced by FabricFlower

Same output, produced using QuiltFlower

New Moderators

Quilt’s community spaces are always looking for new moderators. If you think you’d be a good fit and like to be involved, you can submit an application via ModMail.

Some key documents to be aware of before applying:

If the qualities outlined in the above documents, seem like you… please step forward and apply. The interview process will follow the steps outlined in RFC-7 (TL;DR):

Apply Via ModMail
Interview with a Community Manager (and the wider Community Team)
Community team holds a vote based on the interview
Result of the vote given to interviewee, and if successful the applicant will become a Trainee Moderator

Modding with Quilt & Fabric

Can I mod with Quilt at the moment?

It is currently not possible to mod with the Quilt framework.

However, progress has been made. We are currently waiting on a Gradle Plugin.

We are looking for contributors. If you would like to help out with this part of the project, please reach out in #build-tools-general and express interest. A member of the relevant team will reach out.

Are things still compatible with Fabric?

Things are largely compatible with loading mods.

Mixin Plugins may not be possible to maintain compatibility. We may consider contributing to some mods that use them, to aid in replacing them.

Round-off

That is all for now! When there are more things to talk about, they will be published here; for more bleeding edge changes and updates on the project, follow along on our Discords.

Thank-you to the Quilt Project’s team for helping flesh this out; it would have otherwise been just an update on moderators.

Quilt's (VERY LATE) October Update

Wed, 10 Nov 2021 14:00:00 GMT

Quilt Mappings are now usable in Loom!

Have you wanted to use mappings other than Yarn or MojMap?

Quilt Mappings is a Yarn derivative that allows inspiration from MojMap. This allows for Quilt Mappings to map the obscure constants in Minecraft code and more.

However, this can mean that Quilt Mappings maybe be different from Yarn.

The provided gradle plugin allows Quilt Mappings to be used in Loom and Fabric environments. Currently, it is 1.17.1+ only; with no plans of backporting to earlier versions.

Benefits of Quilt Mappings:

Faster turn around.
- For the past couple weeks, Quilt Mappings has been out before intermediary. While this doesn’t help too much in loom, it is something to look forward to in the future.
Consistent names.
- Quilt Mapping names are never mismatched, meaning you won’t find issues where names swap between versions.
Familiarity of Yarn with the completeness of MojMap.
- While not complete, Quilt Mappings has the goal of 100% mapping coverage for Minecraft. Any help toward this goal would be appreciated as well!

How to use Quilt Mapping (Gradle Plugin)

How to use Quilt Mappings:

settings.gradle

pluginManagement {
    repositories {
        maven { url = "https://maven.oroarmor.com" }
    }
}

build.gradle

plugins {
  // ...
  id "quilt-mappings-on-loom" version "2.0.0"
}

// ...

dependencies {
   mappings(loom.layered {
      addLayer(quiltmappings.mappings("org.quiltmc:quilt-mappings:${minecraft_version}+build.${project.quilt_mappings}:v2", true))
   })
}

New Moderators

Quilt’s community spaces are always looking for new moderators. If you think you’d be a good fit and like to be involved, you can submit an application via ModMail.

Some key documents to be aware of before applying:

If the qualities outlined in the above documents, seem like you… please step forward and apply. The interview proccess will follow the steps outlined in RFC-7 (TL;DR):

Apply Via ModMail
Interview with a Community Manager (and the wider Community Team)
Community team holds a vote based on the interview
Result of the vote given to interviewee, and if successful the applicant will become a Trainee Moderator

Quilt enters Beta

Tue, 22 Mar 2022 05:30:00 GMT

It’s a huge milestone in our development process, and we could never have done it without our incredible teams and supporting community.

It is important to remember that this is a beta, not a full release. Beta software is intended for testing, ironing out issues and having space to develop features ahead of a full release. This means that a beta release will have some features missing, and may be unstable.

Instability

Beta software is inherently unstable. This means that there could be a lot of bugs and crashes, but it also means that anything could change at any time, with no regard for compatibility between one version and the next.

It may be frustrating, but trying different approaches and iterating is an essential part of our development, and during this pre-release stage it is essential to not be held back by backwards compatibility.

Missing Features

Beta software is also generally missing features that will be included in the full release, and Quilt is no exception. All our projects are at a stage where we feel that they are usable, but most of them are still missing features that will be included in the final release. Namely:

Mods will be built using a fork of Fabric’s Loom with Intermediary, instead of Quilt-Gradle with Hashed MojMap.
The Chasm bytecode transformer is not yet ready for use and will not be available.
Loader plugins will not exist.
QSL (Quilt Standard Libraries) will not be automatically downloaded as a dependency.
Many QSL Modules will not be available to use.

Why we’re releasing now

To address the elephant in the room, we’re not releasing Quilt on 4/20 for the memes. April 20th is actually the one-year anniversary of the Community Discord server, a very significant event in Quilt’s history. Besides this, we’re releasing our tools in an unfinished state for two reasons:

Quilt is relatively unknown outside its community, and we hope that by showing that Quilt is more than just an idea, the project will gain some traction, and start being taken more seriously by people in the modding sphere.
Both our developers and our (future) users are very important to us, and we want your feedback and ideas on how to improve what we’ve made, while we still have the flexibility of being in the development stage to change and break things, without having to worry about backwards compatibility.

Stay in the Know

While we are currently confident that we can make the April 20th target, the truth is that software development is often unpredictable, and estimates aren’t always representative of when a target is met. If you want to stay up-to-date with developments, we recommend joining our Community Discord Server, and/or following us on Twitter.

You can even subscribe to this blog via RSS and get updates delivered straight to your RSS reader of choice.

We also hold a Public Developer Meeting on the Toolchain Discord Server every second Saturday at 5PM UTC, where the teams get together and discuss the progress made on their respective projects, and also answer questions from the community. Even though it’s called a Developer meeting, anyone interested in Quilt’s future development is welcome.

Get Involved

If you want to get involved, we could always use some extra help. A list of current openings for positions on our various teams can be found on the Openings page, but if none of them speak to you, or if you want to contribute without joining a team, the best thing to do is to join the Toolchain Discord Server and offer your expertise.

Conclusion

We’d like to thank everyone who has come with us on the journey so far, including our developers and our wonderful community. This is Quilt’s biggest step since we ran out of GitHub Actions minutes and had to go public, and we never could’ve done it without all of you.

Quilt is closer than ever, and we can’t wait.

Introducing BlanketCon!

Tue, 29 Mar 2022 07:00:00 GMT

If you’re a Minecraft mod developer, we want you here at BlanketCon! Submit whatever mods you’d like to feature in the con; size or poularity doesn’t matter! The server will be running on the Quilt Loader beta, with support for both Fabric and Quilt mods, but if you develop for Forge, Sponge, Paper, or any other modding framework, you’re still more than welcome to hold an event - despite being Quilt-run, we want this to be a celebration of Minecraft modding as a whole! You can apply to host a booth or an at-con event at https://blanketcon.modfest.net/signup/!

The con server will open on May 5th at 6 PM UTC, with the opening ceremony beginning an hour later! You can see the full schedule as it’s created, as well as all confirmed booths on the BlanketCon site at blanketcon.modfest.net!

If you have any questions, please don’t hesitate to ask in the ModFest or Quilt discords! I hope to see you all there!

Announcing the Quilt Forum

Sat, 07 May 2022 04:30:00 GMT

You may have some questions about why we’ve launched a forum, and what will happen to our existing Discord spaces, but before we answer those, let’s get one universal question out the way:

The forum is live now at https://forum.quiltmc.org, and you can sign up with a standard email and password, or using GitHub or Discord OAuth. Please make sure to read our Privacy Policy if you have questions or concerns about how your data is handled and managed.

With that out of the way, let’s address some other common questions.

Why do we need a forum?

Currently, our primary community space is the official Quilt Community Discord, and while it is very good for short-form discussions and has served us well, a forum provides two distinct advantages over Discord: Openness, and Control.

Openness

One major problem with Discord is that it is a closed platform. To read the announcements and discussions we have in the Discord, you need to have a Discord account, and you need to explicitly join the server. This creates a barrier to entry for those wishing to learn more about Quilt and see what we’re doing beyond what’s on the website, which many people won’t bother to pass. With a forum, while you still need an account to participate in discussion, if you’re just looking, you can just visit it. There’s no form to fill out, no password to create. A forum will also be indexed by search engines, meaning that any discussions or support requests can easily be found by future modders with a quick search query.

Control

The other major advantage that a forum has over Discord is that it is fully owned and operated by us. Currently, if Discord goes down, we’d all be completely unable to communicate, but having a forum provides a backup place to use if this happens (and it works the other way around too). As well as this, Discord might someday change in a way that make it unsuitable for us to use, or it could even go out of business entirely, but a forum that is controlled by Quilt will exist as long as Quilt does. Even if Starchild Systems becomes unable to sponsor or host us in the future, we’ll still be able to pack the forum up and move it elsewhere, while still preserving its community and discussion history.

What will happen to Discord?

Not all that much. We’ll link up some channels to feeds from the forum so that you can keep track of what’s happening over there, but we have no plans to replace or otherwise deprecate Discord in favour of a forum. Discord is great for hanging out and having easy, short-form discussions, and it’s still our main community space, something which we don’t expect will change any time soon. Our Discord spaces will remain the active and cared-for places they are today, but the forum will also be available for those who prefer to use it.

So what are you waiting for? Head over to https://forum.quiltmc.org and join in the fun! Unless you don’t want to, I suppose?

October: Month of the 'toberfests

Sun, 02 Oct 2022 19:20:00 GMT

But what are ‘toberfests?

Aside from the German beer festival Oktoberfest, the original and most famous ‘toberfest is Hacktoberfest. Began by Digital Ocean in 2013, Hacktoberfest is, at it’s core, a challenge: during the month of October, you must contribute to four participating open-source projects, and the first 40,000 to complete the challenge get a choice of either a t-shirt or a tree planted in your name.

Inspired by Hacktoberfest, several other groups have held smaller challenges, usually focused on a specific type of project. One of these, which this year Quilt is proud to be sponsoring, is Modtoberfest, which focuses on contributions to the Minecraft community. While the prizes might not get you the street cred of a Hacktoberfest t-shirt, a tree will be planted for every accepted pull request, and if you submit four accepted pull requests, you will receive a sticker pack containing, among other things, something that no-one else will have: the world’s first tangible Pineapple. Behold it in all its fruity glory!

You also get a Quilt logo sticker, a Modfest sticker, a BlanketCon 2022 and some others, to complete the collection.

How do I start?

You can start by going to https://hacktoberfest.com and/or https://modtoberfest.com/ and signing up. From there, all you need to do is find a participating project, see what you can contribute, and start coding!

We have a full page with guidelines for making contributions to Quilt specifically, but a word of advice: maintainers of the projects you contribute to have to officially accept the pull requests that you open in order for it to contribute to your total, and most of them will only accept ones that are high-quality and show effort put in for its own sake, not tiny changes that are clearly made in pursuit of a t-shirt (or the opportunity to be able to hold a Pineapple in one’s hands): your contributions should be made with love and genuinely benefit the project that you’re submitting to. Make sure to discuss any changes you want to make with the project’s maintainers before contributing, and make sure to follow the project’s contribution guidelines from the start to minimize their workload in the review phase, and maximize your chances of getting accepted.

Happy hacking!

Adding Cloudflare Web Analytics to quiltmc.org

Sat, 26 Nov 2022 23:45:00 GMT

Analytics and Privacy

Analytics tools are not exactly known for their focus on user privacy. This is because the most well-known analytics tools are run by advertising companies, most notably Google Analytics, which has an 85% market share in the analytics business, and is installed on over 55% of all websites. As well as collecting analytics for the website owner to use, these tools use various technologies (like cookies or local browser storage) to associate users with a central identity. Then, when a user visits a website, they log that user as having visited it to a central database.

While knowing that a user visited a single website isn’t very useful, if an analytics tool is installed on lots of websites (like how Google Analytics is on 55% of the web), it can get pretty accurate data of what websites a person is visiting and what they’re doing there, which can then be used to target ads to them. The website owner essentially makes a deal with the analytics tool vendor: The vendor will provide collect and store the analytics data for free, and in return, they get to watch every user visiting your site, and use the data for whatever they want. This is a great deal for both the vendor and the website operator, but not so much for the website’s users, and as a community-focused product, a deal that benefits us but hurts our users is not one that Quilt is willing to make. Fortunately, there is a better way.

In more recent years, spurred on by the advent of the GDPR and similar privacy laws, many companies have developed more privacy-focused analytics products, one of which is Cloudflare Web Analytics. While there are many similar products available, we’ll be talking about it specifically, since it’s what we’re using for quiltmc.org. Critically, it doesn’t use cookies, local storage, fingerprinting, or any other technologies to associate you with an identity, which means it cannot track you around the web. This means we won’t need to ask you to consent to cookies when you visit our site (even though it would be a great opportunity to make a drawing of Cozy nomming a cookie), because we still don’t use any.

What Data Is Collected

The following list are the main things tracked by Cloudflare Web Analytics. It’s important to remember that because Cloudflare doesn’t log your IP address or use any other fingerprinting technologies, it’s impossible to associate any of this data with any specific person or group. If we looked at site visitor metrics, for example, we wouldn’t be able to see who those visitors were, or what each one of them did; only that some people visited some pages, and some people visited others.

Cloudflare Web Analytics collects:

Visits: When someone visits a page from an external or direct link, rather than an internal link in another part of the website.
Page Views: When someone successfully loads an HTML page on the website.
Core Web Vitals: Performance metrics reported by most Chromium-based browsers and used in Google’s search rank algorithms
Country: What country someone visits from, based on their IP address.
Referrer: What website a person came from.
Device Type: The type of device a person visited with: desktop, mobile, or tablet.
Browser: The browser a person used when they visited.
Operating System: What operating system the person used when they visited.
Page Load Time: How long each stage of page loading took.

Additionally, Cloudflare Web Analytics is fully GDPR-compliant and doesn’t collect any information classed as Personally Identifiable Information (PII).

How We Could Use the Data

Even though Cloudflare Web Analytics doesn’t come with any privacy concerns, it does add complexity to the website that wouldn’t be worth it if we just used the data it provides to make pretty graphs. However, there are real ways that we can use it to make the website better for the increasing number of people that visit it every day. Here are some examples:

The data about what countries our visitors are from will help us know which languages to prioritize for localization.
If we notice that a lot of visitors are coming from a particular social media post, video, or blog article, we can show it to the rest of our users as a way of saying thank you.
If we notice people with certain device types, operating systems, or browsers are having bad experiences (for example, slow page loads), we can look into optimizing the website for them so that they have a better experience.
If our Core Web Vital statistics are low for a large number of users, we can work on improving them to improve our SEO, since they are part of Google’s search ranking algorithm.
If a page is loading slowly for a lot of people, we can see exactly which part of the process is getting stuck and fix it, without them having to go through filing a GitHub issue.

As well as these more practical examples, there is another use for them, which is encouragement. Seeing Quilt’s success in numbers, and how it’s gradually growing and spreading through the web to more and more places, reminds us that what we’re doing is in fact making an impact, even if it sometimes feels like Mojang breaks half our tooling every couple of minor releases. We know that our growth interests our community, too, and while it’s not possible to make the analytics completely public, if all goes well we plan to write a series of blog articles every so often about the website’s analytics, starting with December’s analytics in January.

Why Cloudflare?

Cloudflare has attracted a lot of controversy recently, most notably its initial refusal to stop providing service to the harassment forum Kiwi Farms, so it’s not unreasonable to wonder why we’re choosing to use their offering over one from another company. The reason is that almost all privacy-focused analytics tools are paid, since they can’t fund themselves by selling or utilizing the user data they collect, while Cloudflare offers a generous free tier in the hope that you’ll soon upgrade or try one of their paid products. There aren’t any other really reputable companies offering good free tiers, and the tradeoffs of using Cloudflare do not outweigh the costs that would be incurred from going with someone else.

I hope that after reading this article, your mind is at rest. As the world becomes increasingly chaotic in many respects, it’s easy to think that we’re going the same way as everyone else: launching something new without really thinking about it, and hurting our users in the process, but hopefully, you now understand the reasoning behind the decision. If you have any questions, you can visit #discord-meta in the Community Discord Server, or the Meta section of the forum.

Five vulnerabilities found in mrpack installer implementations

Sat, 04 Feb 2023 17:00:00 GMT

Quilted Fabric API: A call for contributors

Tue, 14 Feb 2023 12:15:00 GMT

She could really use some help, so if you are able and have the time to spare, it would be really cool (dare I say, based?) of you to come on down and give her a hand.

Do I need to join a team?

Absolutely not! Although contributing is often linked to joining a team, we’re actually very happy to accept external contributions as well. You mustn’t feel like you need to commit to joining the team before helping, and it’s generally better if we get to know you and your contributions a little before accepting you onto a team if you want to be on one eventually.

I don’t feel like I know enough to contribute…

Quilt is a big project, and you might think that it’s deeply complicated and requires expert skill to contribute to, but as long as you have basic Java knowledge and are willing to learn, you can do lots of things that would be a big help to us. The more people that contribute, the faster development will progress, and the more viable it is for other developers to take breaks when they need so that they can keep doing their best work. Your help is valuable, even if you don’t consider yourself a skilled programmer.

What can I do to help?

We’ve created a truckload of GitHub issues to get you started, so have a look and find something you think you can do. If you find something you want to take on, make sure to comment on the issue so that others know you’re working on it and work doesn’t get done twice. If you have any questions or would like to discuss changes that you’re planning to make with the developers, come and join us on the Toolchain Discord.

Although this post is focused on Quilted Fabric API, we welcome contributions to all our projects, such as Cozy, quiltmc.org, and others. Even if you can’t code, you can still help in other ways, for example, by translating the website into your language. Join the Toolchain Discord if you’re interested!

Quilt Mappings needs you!

Sat, 03 Jun 2023 12:00:00 GMT

What’s holding the team back?

The Quilt Mappings team is one of the largest in Quilt, but we’re still struggling to keep up. Why? There are a few reasons. Most of the team is simply busy and doesn’t have the time to submit new mappings, and those of us that do have time have other exciting projects to work on! We’re building an entirely new mappings toolchain, always matching to the latest snapshots, and delivering huge improvements to Enigma, the program that we use to create mappings. That’s not to say we’re not working on mappings all the time, though, and we’re always here to deliver quick reviews on pull requests!

Why even bother?

Quilt Mappings (or QM for short) is different from the other two sets of maintained mappings on the market: Mojmap and Yarn. We check our names against both sets constantly to make sure that we’re delivering the most accurate ones possible. Mojang names are often unintuitive, and aren’t built for modders: they’re made for the developers working on the game itself. Contrary to Mojmap, Yarn aims to deliver names that are easy to understand for modders, but since their names are not checked against Mojang’s intentions, they can sometimes be confusing and contradictory to the intended usage of the code. Both sets are excellent on their own, and QM is made to be a hybrid of the two, shipping clear, concise, and accurate names inspired by both. We’ve also implemented extensive checking for typos, Britishisms and convention violations to make sure no problematic mappings are published. Despite their drawbacks, Yarn and Mojang have 99% and 100% completion of class names respectively, and we can’t truly call ourselves the best with our measly 98.

How can I help?

The biggest way you can help with QM is by contributing new mappings to the large swaths of the game that are missing names. All you need to help out is knowledge of Java! We have a couple cute documents already written up on how to contribute: check out our CONTRIBUTING.md to find out everything you need to know before mapping! Making new mappings isn’t the only way to help, and if you want to improve our existing names, our issue tracker is a great place to find suggestions of names to change. However, be warned that if you change names made by me you run the risk of incurring my wrath (affectionate). Opening Enigma will immediately give you an idea of what needs doing in terms of new mappings, thanks to our handy little status icons next to each class. If a class has a check mark, you can move on, but anything with a yellow dot or red x needs your help! This adorable graph, generated by the Mapping Stats feature in Enigma, can help show you where to start. As always, we’re happy to help you out with anything: using Enigma, what to name methods, where to map, etc! You can always talk to us on our Discord.

If mapping the game is less your thing, we have plenty of other projects for you to help out with. We can also use the help of those experienced with Java, networking, Swing, Gradle, and even translation. Contributors have a few great options:

Working on our new toolchain, which we’re calling Quilt Mapping Tools. You can help with designing the toolchain, writing Java code, designing the new mapping format, or even preparing other parts of Quilt to use QMT. The best way to find out what needs doing here is talking to our team leader, OroArmor, on our Discord! You can also check the QMT issue tracker to get a rough idea of the work that’s still in progress.
Helping out with our deobfuscator, Enigma! Improving Enigma helps us make mappings faster and with fewer mistakes. To help out with Enigma, you can look at its issue tracker, or try to break it to help us find more bugs. In particular, we’re looking for help with solving a pesky ui issue detailed here. Enigma is quite a complicated program, and you can always talk to me (rai), or Martrixx on our Discord if you’d like some help understanding it. Enigma is separated into four parts: a backend, a command line interface, a server, and a swing GUI, which means there’s something for every type of Java experience! If the language you speak isn’t English or Java, Enigma also has internationalisation support! You can add languages in the lang folder, or complete translation for existing languages! Compare against the en_us file to find missing translations.
Tinkering with our existing tooling! Our new set of tooling is nowhere near completion, and the stuff we use right now still needs maintenance and improvements. You can check issues marked as “toolchain” in our main repository to see what needs work right now.

Thank you for reading, and we’ll see you on the creature trail! - rai

Evil Modding Project Adds Telemetry

Mon, 26 Jun 2023 12:00:00 GMT

Update 17/09/2023: The beacon has been permanently removed in Loader 0.20.0 following the decision that the usefulness of the MAU statistic is outweighed by community concerns and confusion regarding telemetry.

Why are we doing this?

Excellent question, dear user. Over the last couple years of Quilt, we’ve been running a website, a repository of compiled binaries called a Maven, and other miscellaneous bits that we need hosting for. One of the best ways for projects like us to pay for our infrastructure is by getting a sponsorship: a company agrees to pay some of our costs, for the low low price of an icon on the website or something similar. Since they’re a company, before agreeing to take on the financial burden of an entire project, they first want to make sure that people will actually see that icon: that’s where Monthly Active Users, or MAU, come in. MAU is a pretty universal statistic that shows how popular something is: my personal website has one MAU, which is just me coming back every once in a while when I add something interesting, while a big service like Github has millions of MAU from people coming back all the time to view and commit code. Every unique person who visits that month bumps the MAU number by one. Our potential sponsor gets to see that and go “ah, there are a pile of people playing on Quilt, that means a bunch of folks will see our little ad and check us out!”.

Another huge benefit of having an MAU statistic is that Quilt developers like me get to see just how many people are using our passion project, which is great motivation for us to keep improving it! I’m sure it’ll always be fun to see how many of you are running around inside a Quilt-powered version of the silly block game.

How are we doing this?

As neatly laid out in the RFC, the process is very simple. When you load up your game, Quilt Loader will check for a file that’s shared by all your instances of Minecraft, that contains the last date that it told our infrastructure you’re a user. If that month is the current month and you haven’t opted out, Loader will move on to updating the stats. After running the opt-out and date checks, this process is entirely separate to loading your game, and won’t slow anything down.

When Loader has assessed that you’re not yet considered an active user for this month, it sends a simple request with no data; no body or headers, to an endpoint at https://quiltmc.org. The server updates the counter without storing any identifying data. Then, Loader updates its persistent file with the current month, and continues on its merry way.

Will this steal my data, the family cat, and possibly my wife as well?

The biggest consideration when designing this feature was privacy: we want to get the numbers, and absolutely nothing else. This means that while your IP address will be sent to our website once a month, we discard all information except the +1 to our counter as per the restrictions in the RFC. The server accepting the signal is fully open source and will remain that way so anyone can see what we’re doing with what you send us. Additionally, since Quilt Loader is open source as well, you can see all the code sending the signal in the MAU beacon pull request.

I don’t like that, how can I say no?

There are two simple ways to opt out of being counted.

When running Quilt Loader, add a property, -Dloader.disable_beacon=true, to your Java Arguments. In the official Minecraft launcher, you can do this by going to installations -> edit -> more options -> jvm arguments and appending that to the end. If you’re using another launcher, check its documentation or poke around to find the same thing. Loader also has a collection of other useful properties, nicely documented in its wiki.
Set the QUILT_LOADER_DISABLE_BEACON environment variable to true. An environment variable is a value that is visible to all programs, so using this method will opt you out on all your installations.

Though it’s easy to disable, it would be lovely if you left it on for us. Who doesn’t love a number getting bigger?

Quiltflower is now Vineflower

Sun, 09 Jul 2023 14:55:00 GMT

Despite the separation and the change in name, we expect that very little will change for Quilt developers: We will continue to use Quiltflower — now Vineflower — in our toolchain as we always have.

Why did this happen?

Although decompilation is a core part of Minecraft modding, decompilers aren’t inherently related to Minecraft in the same way that Quilt Loader or QSL might be, and so the decompilers team hasn’t really ever operated like the rest of Quilt’s development teams. Because of this separation, they felt that it would be easier to develop Vineflower independently of the complexity that comes with having to coordinate the operations of an entire modding toolchain and its associated community.

Although we will be sad to see the decompiler team go, we’re very proud that they have managed (the geniuses that they are) to make Quiltflower into one of the best Java decompilers in the world, and bring it to a point where it is ready to leave our cozy nest, and blossom into its own amazing project.

If you’d like to show the new Vineflower team some love, you might send them a Star on GitHub.

Quilt Loader Telemetry Explained

Wed, 12 Jul 2023 11:25:00 GMT

Update 17/07/2023: The beacon has been temporarily disabled following a report that it was erroneously storing IP addresses. Please see this forum post for more information.

How the telemetry works

Most telemetry is gathered with the intention of precisely learning how different demographics of people are using a product, perhaps with the intention of analysing behaviour to fine-tune an algorithm, interface, or marketing campaign. The word “telemetry” is associated with all sorts of sensitive data: your IP address, your location, the intimate details of how you’re using an app, but we’re not collecting anything like that. In Quilt’s case, we only need to know how many people are using Quilt in the wild, so we optimised for sharing as little data as we possibly could while still accomplishing this goal.

When Quilt Loader is launched, it first checks if the user has opted out of telemetry (more on this later), or if it has already added you to this month’s active user count. If it neither of those apply, it sends an empty request to beacon.quiltmc.org, containing no data except the bare minimum that it needs to establish a connection. No identification, no information about how you’re using Quilt Loader, no nothing. It then records the fact that it has made this request in a local file that is shared among all your Minecraft instances, so that it doesn’t send any more requests that month. After receiving the request, the Beacon server increments the Monthly Active User counter, logs the request as a simple timestamp, then deletes all the connection data associated with the request that it just received.

Image Credit: ix0rai

It’s important to emphasise just how little data is being sent here. You’re sending more data away if you:

Play Minecraft itself.
Use CurseForge, Modrinth, or any mods or launchers that integrate with them (such as Prism or ModMenu).
Connect to any website on the internet.

If you want to dig into the exact workings of the system, you can look at Quilt Loader PR #326, RFC 81 which outlines the functionality of the active user beacon, and the Beacon server itself, which is fully open-source.

Why are we adding telemetry?

Monthly Active Users is a statistic used all over the technology industry, often as a way to assess a platform’s size or value. Although we’ve made sure that the telemetry we’ve added is as privacy-preserving as possible, it wouldn’t be worth the disadvantages, however slight, if we didn’t actually need it for some reason.

The main reason we need a Monthly Active User count is that many companies and organisations are reluctant to work with us if they don’t consider us large or consequential enough to be worth their time. Most notably, CurseForge asked us for a Monthly Active User count when we enquired about launcher support for Quilt. Additionally, although this hasn’t happened yet, knowing our Monthly Active User count gives us a widely-accepted measure of size to use when applying for any sponsorships, grants, or other partnerships that we may need in the future.

But Why Couldn’t You Just…

We did consider some alternatives, however, everything we came up with was unsuitable for various reasons:

Measuring QSL downloads is inaccurate, because everyone downloads a new version of QSL whenever it updates.
Measuring Installer downloads ignores a large portion of users who use 3rd-party launchers, like Prism.
Measuring downloads of the Loader itself from Maven is technically infeasible because it is downloaded directly from a cloud storage bucket, and there’s no point where you can reasonably insert a counter for download requests without spending lots of money.

Additionally, all of those methods simply measure download count, which, while a useful statistic, is not as universally accepted as a Monthly Active User count.

How to disable the telemetry

If, despite the precautions we’ve taken to measure telemetry in a privacy-preserving way, you’d still like to disable it, there are a couple of ways that you can do so.

Add the Java argument -Dloader.disable_beacon=true. In the vanilla launcher, you can add Java arguments in Installations -> Edit -> More Options -> JVM Arguments. Note that this will only disable the telemetry for the Installation that you add the Java argument to.
Set the environment variables QUILT_LOADER_DISABLE_BEACON or CI to true. How to do this varies in complexity based on your OS:
- In Windows, you can add a new environment variable in Control Panel
- In Linux, you can usually add the line QUILT_LOADER_DISABLE_BEACON=true to the /etc/environment file, but this can vary by distribution.
- In macOS, there seems to be no reliable way to set environment variables for the entire system, as opposed to just the zsh shell. We recommend using Java arguments instead.

Edit: 2023/07/12 12:50PM GMT: Clarified that CurseForge takes Monthly Active Users as a consideration, not as a requirement. Also clarified that the Beacon server saves a timestamp, and fixed instructions about adding the beacon-disabling environment variable (thanks Leo!) Edit: 2023/07/13 19:45 GMT: The environment variable to disable telemetry is QUILT_LOADER_DISABLE_BEACON, not QUILT_DISABLE_BEACON (thanks esoterica!)

Quilt's (EXTREMELY LATE) November Update

Thu, 28 Sep 2023 15:00:00 GMT

Quilt Standard Libraries

QSL has received just over 30 new APIs in the time since we last posted about QSL development on the blog. We’re making the executive decision that that reflects on how amazing its contributors are at making APIs, and not how slow us over in the writing team are with releasing our blog posts. Before you start thinking about just how long it’s been, let’s get into the updates!

Starting off with April of 2022, we saw the initial version of the Registry Entry Attachment API, or REA for short. This is a pretty unique API that allows developers to associate arbitrary values with any objects managed by registries, such as items or blocks. If you are familiar with Java’s collections, this functions as a Map, connecting registry objects to values, like how tags function as a List of items with a certain property. We’ll see later how this is useful by taking a look at a few of the APIs that rely on it. It has continued to get updates, and is now incredibly powerful. It’s not limited to simply registering through code, and supports datapacking so that more than just mod developers can make use of it! REA forms the basis for quite a few other Quilt APIs, such as the API for adding enchantment table boosters, flammable blocks, and compostable items.

In May, we added an API for registering new resource pack providers. This allows mods to use code in place of making their own static resource packs in the files, which lets developers do neat things like generating textures at runtime, and then zipping them up into a resource pack that can be applied and removed in-game at the user’s will! As always with a unified API, this also means fewer conflicts between mods all trying to do the same thing with the same mixins.

Not stopping with the new APIs, we added our own Block Entity API, which gives developers the ability to register their own block entities, sync their data from server to client, and use the same block entities on multiple blocks! An essential for a full Minecraft modding API, this is an important step towards making standalone development with QSL possible for big mods. In addition, we shipped two other big updates:

Caching for mod-provided resource packs, which was quite a big improvement to resource reload performance! It reduced the startup time of the Blanketcon 2022 modpack by seven seconds, according to some simple benchmarks.
Added a configuration option to disable Minecraft’s “Here be dragons!” warning screen, since it’s pretty much impossible to avoid triggering it when making mods that touch world generation.

Speaking of world generation, in July we introduced another unique new API in the form of the Surface Rule API. This is a neat little system for injecting new types of surface world generation into the three vanilla dimensions. You may know this from the iconic Trans Ground test mod, demonstrates the power of this API by turning the ground into a beautiful, pastel transgender flag. In addition, we shipped the Item Content Registries API, allowing you to attach compostability and custom fuel times to your items!

August brought yet more uses of the REA system, with the Block Content Registries API! Just like Item Content Registries giving us data driven fuel times and compostability, Block Content Registries gives us control over stripping, waxing and flammability in our datapacks! But if you’ll believe me, that’s one of the smaller APIs in terms of code this month. We also got:

Registry sync! This is yet another critical step towards standalone QSL development. Registry Sync is short for registry synchronisation, which makes sure that both your Minecraft client and the server you’re connected to have the same sets of items, blocks, entities, and other things. It’s necessary in order to have content mods working QSL-only.
The Multipart Entity API, an API for creating your own huge, complex entities. The “multipart” in the name comes from the fact that this is support for entities with multiple sub-parts, like the Ender Dragon. The dragon has multiple hitboxes, and now you can too!
Alas, a sad story. The QSL DataFixerUpper (DFU) API was a short-lived feature that allowed developers to register their own Datafixers, the same system that Mojang uses to upgrade worlds between versions. This API ran into a critical problem: DFU wasn’t built with a heavily modded game in mind, and it had issues, namely with trying to update the IDs of items in modded containers. Press F to pay respects, and other gamer-y things here. I write more code nowaways than I play video games. Sad.
To finish off this amazing month, we introduced the Bow and Crossbow APIs, making it simple to add your own bows and crossbows in your mods. Nice!

In September of 2022 we had another massive month (two in a row!) with 4 cute new APIs. These include:

A fully featured Virtual Resource Pack API, building off the work done in the Resource Pack Provider API in order to provide more goodies like in-memory resource packs, events, and better ways to add resources to packs.
A big set of entity-related events, allowing mods to easily react to events like entities being killed, entities being loaded, entities moving between dimensions, and more!
A pile of entity object builders to simplify setting up points of interest, vehicles, villager trades, and (again) more!
The Recipe Remainder API, allowing you too to leave buckets behind when making recipes for your custom cakes. Someone more creative would have come up with something cool to suggest doing with this API. I am not that person. We are looking on suggestions to help with a duplication issue for the API, so give your advice!

Next month we finally calmed down for the winter, introducing a new set of events for registry manager setup and loading, and fixing a small pile of bugs. A nice October.

In November, we added the Entity Selector Options API, allowing modders to better integrate their features with Minecraft’s commands system via meshing into the way entities are filtered for autocomplete. Additionally, we added a big API: the Status Effect API! Using it, mods will be able to easily add status effects, and customise things such as whether the effect will be cleared when drinking milk. Amazing!

Moving on to 2023, In January we added an API for listening to and modifying chat, highly useful for server mods! After that, we added the Armor Rendering Registry API, allowing registration of, as the name implies, different types of rendering for armor that are associated with certain armors. It’s since been updated with support for layers, and is quite powerful!

In February we shipped one big new API: Quilt Game Tests. This is a helpful API for using Minecraft’s fantastic Gametest system, which is the way that Mojang themselves test the game before releasing updates. It lets you easily create tests by building structures in-game, and then writing code that uses that structure and defines a test with an expected result. For example, you could write a test that uses a rail structure, places a minecart on it, and tells the game that after 10 seconds the minecart should reach the other end of the track. Neat! Using this API is the perfect way to help make sure that your mod is bug-free. Which admittedly us developers are pretty bad at. But if you are one of the rare folks who has the patience to write tests, this is the perfect API for you!

Rapid fire API time! Let’s go through March and April why don’t we.

March brought a couple new entity-related events to help you out with writing reactive code. Cool!
April gave us the Dynamic Registry Registration API, which, well, allows you to register your own dynamic registries. This means that you can hook into Minecraft’s registry system and define your own data to be loaded from datapacks, allowing users to heavily customise your mod without touching any code.

As seems to be usual, May was also a big month for us! In QSL, that meant the Data Callback API, the Entity Spawn Data API, and Registry Sync V2. Let’s see them!

Registry Sync V2. This is an enormous update to Quilt’s registry sync, which we talked about a while ago in this post! First, it adds a system for protocol versions, which allows you to define what’s compatible with what, instead of registry sync deciding for you. Secondly, we released validation of block and fluid states, which enables more reliable sync. But we weren’t done! This update also adds more configuration, such as disabling sync outright, an API for checking what optional entries the client has, and much better error messages.
Entity Spawn Data API. This is a helpful little API that allows you to add more context to entity spawns, making creation of entities with different variants easier! For example, this could be used to outdo my own mod and make the best rainbow entity system out there!
Finally, keeping in line with Quilt’s excellent support for datapacks, we added the Data Callback API, which allows making events controlled by datapacks! This API allows you to make separate “event” files to modify data-driven values.

Since May, we’ve been cleaning up code, fixing bugs, and mostly adding minor features. QSL is becoming a super solid collection of APIs, and I’m not sure I realised just how solid it was until writing this post. We’ll be right back after I port my mods.

Quilt Loader

Loader has seen an incredible amount of innovation, from going, to quote the team, “stable-ish” in May of 2022 to the beginnings of loader plugins early this year. Let’s get right into it with the first release: 0.16.0!

0.16.0 came to us with a massive amount of bug fixes, to make sure we were ready to uphold our promise of stableishness. It didn’t have many flashy updates, but was important to make sure loader was ready for the big features that were to come, the first of which being support for Fabric loader internals! While using internals is still heavily discouraged by both us and Fabric, this means that we can have better compatibility for mods whose developers who haven’t yet had a chance to update their code.

Next month, we (or, well, Glitch and Alex. For some reason when you develop for Quilt you end up considering yourself part of a hivemind. undiagnosable) shipped quite a big new feature: the initial version of our unified configuration library, Quilt Config. This library aims to finally resolve the ancient modding issue: “every mod JiJs nightconfig aughhghhhhhhhhghhh” by making sure every developer has access to configuration utilities right in the loader. By default, Quilt Config supports TOML and JSON5 reading and writing, and has the capacity to be extended for more file formats if you’d like to toss us a contribution! It’s consistently being updated, with new goodies like the ReflectiveConfig API having arrived earlier this year.

In August of 2022, the mod table was delivered to the world. This is a new way of showing mods in logs that has a couple important innovations over the old tree-esque design. It allows us to:

Show far more information in the log files, providing critical details for the tireless helpers in our Discord, forum, and elsewhere to use when fixing issues. Neat!
More easily parse the log for ✨automation✨! If you hang around the aforementioned Discord server, you may have noticed our adorable bot Cozy searching through logs and helping (quite literally) hundreds of users. Cozy has the ability to detect Quilt-incompatible Fabric mods, analyse which mods are erroring, and provide tons of other help via parsing logs.

The Loader team wasn’t done yet though, and came back in October with their biggest update ever, 0.18.0. This release, along with having more beta versions than I had previously thought possible, introduced new annotations, better errors, and subfolder mod loading! Let’s run through what those mean.

Our own @ClientOnly and @DedicatedServerOnly annotations. These replace Fabric’s @Environment annotations, and allow mods to avoid pesky sidedness errors. Lovely!
Better solver errors. Solver errors are the “the game can’t load with this mod!” things you’ll see in the window that opens if the game crashes when launching. We cleaned up quite a few things and updated some particularly nasty ones to make most readable by those who haven’t invested more time into developing for Quilt than they have playing the game.
Loading mods from subfolders! This update gives you some amazing control over the way your mods are loaded, with a few handy tricks outside the main feature of searching all subfolders of the mods directory for more delicious mods to load. For one, all folders that start with a digit will be checked against the current Minecraft version, and only loaded if it matches! This means that you can name a folder, for example, 1.18 , and mods in that folder will only be loaded if the current game version is 1.18. You can also specify greater than or lesser than by naming your folders >[version] and <[version] respectively. To cap things off, folders starting with a dot (.) will be ignored entirely.

In November we swapped over to a new standard called FlexVer by Unascribed that helps us more cleanly sort versions and extends the SemVer major.minor.patch convention used by… well… most everything in the open-source world. In particular, this helps us out with mods who use versioning schemes that can’t be translated into the 1.2.3 world of SemVer without a major rethinking of some things. Which is exactly what FlexVer does! The team also wrote up a fantastic GitHub wiki and added per-game-instance configuration of Quilt loader settings, which are, predictably, documented on that wiki!

Not stopping for a minute, Alex and Glitch then gave us a December present in the form of dependency overrides! This is a clever feature that will let you change things about mods’ dependencies without having to go to the bother of recompiling them. For example, this is useful if a mod has a hard dependency on a Minecraft version, but you want to test if it works on the bleeding edge of block games. Dependency overrides let you change the mod’s Minecraft dependency to whatever you want, letting you try it out on other versions! Do note that if you’re messing with dependency overrides you can’t expect mod developers to support you at all. Mods can’t be expected to always work on other versions of the game, but if you’re lucky you might find some!

After spending a month restraining themselves from releasing more versions, 0.19.0 came in February of 2023! This brought initial support for one of the big features we set out to make with Quilt: loader plugins! This is a system that allows an all-new type of mod to be created: a mod for the loader itself. Some examples of things that you could do with loader plugins are hooking into mod loading to add support for different programming languages, mods from different modloaders (in fact, Fabric support is implemented internally via a plugin!), and other delightful nonsense like pre-launch GUIs. As of writing, support remains behind the -Dloader.experimental.allow_loading_plugins=true JVM flag, but progress is continuing on refining plugins and adding functionality for their full release. This release also brought support for another flagship Quilt feature: Chasm, our replacement for Mixin! Chasm allows for more compatibility in between mods modifying the same Minecraft code. Currently, Chasm support remains more proof-of-concept than anything as Chasm hasn’t yet reached a fully featured release. In order to try it out, use the -Dloader.experimental.enable_chasm=true flag! To finish things off, Quilt loader solved the age-old of mods breaking randomly due to internal changes by heavily restricting access to its internal classes. Although it’s a bit more complicated than that. To avoid breaking existing mods with dependencies on internals, this will only apply to new internal classes. The same system can also be used via the @ModInternal annotation, which modders can put on their own classes to seal them off from tampering!

In June, we shipped yet another big version of loader! This one further improved solver messages, as well as adding some new features:

A per-instance cache for storing sorta-persistent files. This comes with a nice API for developers to use!
A new API that developers can use to open up custom error dialogs, the same way loader does for version mismatch errors and whatnot. This API also allows the developers to implement buttons to help the user fix the issue. Neat!
Finally, a bunch of internal file system things were reworked and rewritten in order to make loading mods faster and lighter, using much less memory and much less time.

Just next month, the loader team gave you better dependency overrides, as well as a global configuration and cache! As with all good things, the dependency override format is defined in the loader wiki so you can get straight to overriding.

To finish things off, last month’s updates delivered:

Yet more memory usage and speed improvements, helping you to play more Minecraft and spend less time waiting! Send your local loader team some love today.
Mod validation! This is a helpful tool that our developers can use to check for bugs in Quilt loader, and that means it’ll help us fix more of them!

Quilt Mappings

Quilt Mappings has had an amazing year, and it’s not even because I made my debut on the mappings team! This post isn’t going to cover name updates, only tooling updates, since name changes are going on constantly in the background and if we tried to name every PR we’d be here all day. Speaking of tooling, we’ve introduced an absolutely critical feature allowing mappings on loom, improved linting, completely overhauled our mapping editor, and added more automatic mapping! Starting with June 2022, let’s take a look.

To start off our post-beta bettering, we moved over the functionality of Fabric’s Stitch tools into our own in-house Enigma plugin, which makes the structure of mappings as a whole quite a bit cleaner. Neat!

Next, in July, we upgraded our newly created plugin with a new feature: automagic mapping for simple fields. This allows Enigma, the tool we use to make mappings, to derive names for fields and parameters out of a manually written file. For example, since in most classes there’s only one Codec field, it will automatically be named CODEC by the plugin. Lovely! This allows our mappers to do less work, and is generally really cool.

Moving on to October, we introduced the single most important addition to QM: intermediary publishing! Those who aren’t deep into modding are probably asking: what in the name of Pineapple does that mean? Good news: I’ll tell you. Quilt uses our own system called Hashed Mojmap, which takes Mojang’s official names and scrambles them into copyright-free hashes for us to use at runtime, making sure that we’re not violating the terms of Mojang’s official mappings while decreasing the chance that names will change with Minecraft updates. A Quilt mapping looks like this:

FIELD f_abcdefg MAX_APPLES F

Its type, followed by its hashed name, followed by its mapped name, followed by its class. Contrarily, a Fabric mapping will use something more like field_783462 in place of the hashed name, using a specification they call Intermediary. We introduced Hashed to fix a couple issues with Intermediary: namely, Hashed allows for the mappings to be automatically generated instead of manually like Intermediary. So why does any of this matter? Well, Fabric’s Loom tool that’s used to compile mods only understands Intermediary mappings, and doesn’t understand how to apply Hashed mappings to Minecraft. This means that Quilt Mappings in its base form is incompatible with Loom. We’ve patched this in our version of Loom, but it means that Quilt Mappings can’t be used to develop Fabric mods. Intermediary publishing solves this, by providing both a Hashed-based and Intermediary-based version of Quilt Mappings for you to use, allowing development using QM on Fabric!

In December, we saw an arguably more important toolchain update: to quote my notes, “SAY HELLO TO IX0RAI BAYBEE WE’RE SLAYING IT’S MAPPING TIME” (I joined the team. This is important because it’s my blog post and I can do whatever I want). We also introduced more checks to be run on pull requests, such as making sure that mappers haven’t accidentally left mappings in the default net/minecraft/unmapped package. Cute!

Continuing with improving our mapping lint action in 2023, we added a new check for spelling issues, simultaneously resolving dozens of typos all around the codebase! The final count resolved to about 100 typos that slipped through the cracks, and our check prevents this from happening again. Still in January, we focused on Enigma’s GUI element for a little bit, fixing some major problems to help mappers work faster. First off, our most sly and mysterious mappings team member, Iota, had already given you decompilation via the incredible Vineflower decompiler, making the code you’re mapping easier to understand. Of course, being the queen she is, she only announced this enormous feature to one single channel on the Discord. That’s not even to mention the superb keybind system she introduced even before that. But going back to the present day, we gave you the ability reorganise and the right and left panels as well as close them, giving more personalization as well as more space for your code! We also introduced a merged class tree panel letting you see both obfuscated (unmapped) and deobfuscated (mapped) classes together in one place. Moving away from Enigma, we also added a helpful feature for PR review: comments on your commits to show the code difference, which gives critical context for the actual impact of a rename.

In February we kept working on enigma, implementing new, clear notifications, which trade off the Red Triangle of Bad UI Design in favour of the bubble style used by most everything. Longtime mappers will know what this means. We also cleaned up quite a bit of code and added restoration of recent projects, bringing Enigma closer to being a more standalone app! No, we’re not trying to be more like JADX. We’d never do such a thing.

Over the next few months, we kept improving mapping linting (validating mappings for issues before a release), adding more tests, and packing Enigma with more features! The biggest addition to Enigma was cute little icons next to each class in the tree, letting you tell at-a-glance what needs work and what’s complete. We also implemented some new features into the plugin, including an extremely cool feature which will automatically map getters and parameters for a field when you name it. The mappings team is always looking for more members, so if you’d like to contribute to our tooling or improve our mapping coverage, make sure to let us know!

Finally, we have quite a few ongoing projects, including:

Quilt Mapping Tools, our new unified backend for mappings tooling. This will help simplify the web of projects that contribute to each and every release of Quilt Mappings, and consequently take some load off your local QM wizards via allowing mere mortals to understand how all this works.
Yet more updates for Enigma, including migrating to the aforementioned Quilt Mapping Tools. Enigma 2.0 will be more than just that though, and work is continuing in the background on it. You can check out the milestone on GitHub to see what’s planned so far.

Quilted Fabric API

Despite QFAPI being one of the less flashy cogs in the Quilt machine, it still requires quite a bit of love. Luckily, our fantastic QFAPI team, having expanded by two members just recently, is up to the task! While most of the work is simply updating to new Fabric and Minecraft versions, there have been quite a few changes to its internals! Of course, with this project always needing to keep up with FAPI, contributions are very welcome.

Firstly, we’ve Quiltified four Fabric APIs! This is an admittedly silly name for the process of taking an API from Fabric API and turning all its methods into overloads of QSL APIs, simplifying the project overall. Every API Quiltified is one less API relying on Fabric code! The APIs ported over the last while are:

The Screen API
Fabric’s Registry Sync
Entity Load Events
Block Content Registries

Finishing off our 2022, we introduced a helpful safeguard against mod errors that Ennui has previously posted a devlog about on our Discord. To summarise quite a long post, since QSL’s APIs for attaching properties like flammability to items and blocks is based on Registry Entry Attachments, attachment of those properties can only be done on items that are already registered. Fabric’s APIs take a more static approach, which means they lacks that kind of validation. Since we of course can’t expect mod developers to change their code for compatibility, we came up with a clever solution: Deferred Queues. To simplify it a little, when a mod tries to register properties for an item or block that is not yet in Minecraft’s registries, QFAPI will intercept it and only apply the property once addition to registries is complete. With that, we perfectly replicate the behaviour of Fabric’s APIs without relying on them in QFAPI!

Chasm: Collision Handling ASM

Chasm has improved a lot in the last year! It’s been going through constant planning, prototyping, and testing, and has seen two big events in what I’ve dubbed the Chasm Timeline. Firstly, Chasm and its tooling hit version 0.1.0 in July of 2022! This update had three key points.

Firstly, quite a bit of the backend was reorganised and rethought from the prototype in order to create a much faster system! A must for the end goal of using CHASM as the new backend powering Mixin.
The internal library used to parse compiled transformations into something ready to be applied has been moved from Antlr4 to an alternative called JavaCC21. This allows CHASM to be used as a standalone JAR, without any runtime dependencies.
The specification for Chassembly files, or the compiled transformations Chasm will read when the transformations are to be applied, has changed quite a bit! It’s now a more or less stable format, with no more major changes planned.

And now, the flashier point: our old project lead, CheaterCodes, managed to use Chasm to modify Minecraft! Here’s the obligatory iconic screenshot of Minecraft’s splash text overridden via Chasm.

Finally, since the Chasm team can’t actively work on the project for various reasons (mostly lack of motivation), we’re looking for folks who can take it to the finish line! You can talk to the old team in the Discord if you’re interested on getting this unique tool into production.

Quilt Kotlin Libraries

From its introduction in June of 2022, to its stable release in December, to today, Quilt Kotlin Libraries has been being updated, QFAPI-esque, to new Fabric Language Kotlin versions by its tireless team. Despite that, they’ve still managed to find time for quite a few updates! This includes a huge set of builders, or easily ways to instantiate objects, for commonly used Minecraft classes:

BlockSettings
ItemSettings
Various recipe classes
Registry attachments
Commands with Brigadier

We’ve also introduced two DSLs, or Domain Specific Languages, for working with the aforementioned Brigadier and with registries. These are sort of mini scripting languages that make it both easier and faster to work with their target system. As an example, here’s two different ways to register blocks with the Registry DSL:

RegistryDsl("modid") {
    Registry.BLOCK {
        TEST_BLOCK withName "test_1"
        TEST_BLOCK withName "test_2"
    }
    TEST_BLOCK withName "test_3" toRegistry Registry.BLOCK
}

This keeps a more natural language order as well as concise grammar, and just makes your code prettier!

There’s also a veritable grab bag of miscellaneous other utilities, such as a Kotlin wrapper around event registration, overloads on math operations for vectors and positions, and Kotlin serialization around Codecs. The Kotlin team has also set up a few wrappers to make working with QSL’s Java syntax nicer.

Cozy

Moving away from Minecraft for a minute, what have we been doing with our in-house Discord bot, Cozy? Unlike the bots I made back in my Phase (we don’t talk about how I learned to code), it’s been getting consistent updates! Let’s run through the big ones.

Cozy now has a command that gives you a self timeout, meaning it’ll prevent you from sending messages, but you’ll still be able to read messages. This is nice for when you need to make an exit from a heated discussion, or just need to force yourself into taking a break from Discord for a bit.
We’ve implemented our own AMA, or Ask Me Anything module, to use during our usually-monthly development updates. On the first Saturday of every month, we poke our developers to escape their IDEs for a couple hours and talk about what they’ve done the previous month, so that the community can stay caught up with what’s going on in the World Of Quilt. Cozy’s AMA system helps us with the end of the meeting, where we open ourselves up to questions and let everyone ask the developers, as the name implies, (almost) anything!
All Cozy modules have been published on our Maven server, for use as libraries in your Kord projects. Neat!
Finally, the thing that all Quilters know Cozy for: log parsing. This is an absolutely incredible feature that detects when Minecraft logs are posted in the Discord, and analyses them to see if there’s a simple solution. Cozy’s log parsing can detect Mixin failures, out-of-date first-party libraries (QFAPI and QKL), mods that will have broken features, Fabric mods with Quilt replacements, and mods that are incompatible with Quilt! The list of incompatible mods is open-source on our website repository, so please open a pull request or tell us on the forum post if you find any new ones!

Miscellaneous Updates

Finally, let’s throw in a few miscellaneous updates. This isn’t an exhaustive list, but these developments caught my eye!

We’ve cleaned up and improved the specifications of our Meta server, giving it a fancy new OpenAPI coat of paint as well!
The Community and Toolchain Discords servers have been merged into one monolithic server, where both the developers and the community will be able to live together in harmony until the Fire Nation attacks.
Quiltflower, our decompiler project, has become Vineflower! Moving out of the umbrella of a Minecraft-centric project means that the Vineflower team can simply deal with the decompiler, and not worry about the rest of the project, which many of them didn’t have a large hand in. While we’re sad to see the team leader Jasmine and the rest of the developers go, it’s amazing to see something incubated in Quilt becoming an even bigger project! You can read more about this change in its dedicated blog post.
The Quilt Wiki, your favourite resource on how to mod with Quilt, is finally gaining some steam thanks to a rewrite! We’ve just merged a huge PR to outline the planned structure of the wiki, add a couple critical articles, and clean up the look of the rewrite. If you’d like to contribute, we’re always looking for writers!

Quilt Development Update: November 2023

Thu, 30 Nov 2023 15:00:00 GMT

We intend to publish an update at the end of each month, and they’re going to replace the development update meetings hosted on Discord. We’re still going to be hosting Q&A sessions there monthly (dates are TBD), but we’ll no longer be having developers read out updates to you via the voice channels. With that said, we hope that this move will make development updates more accessible and easier to follow!

This has been a fairly slow month for Quilt, but we still have a few interesting changes to show you!

Loader

Loader has seen a few big PRs this month, thanks to Alex’s tireless work. First, the biggest PR in terms of code changed of anything in this post, is solver pre-processing. This is a large update to the way that Quilt Loader optimises the mod set, essentially making sure that mods and their dependencies are set up in the best way possible. In 0.21, we limit the optimisation process to 5 seconds maximum. Thanks to improper implementation of that process, removing this limit means that the Blanketcon 2023 pack takes over 20 minutes to optimise. With this newest PR it’s now 60 milliseconds. Nice!

There are tons more new APIs, bug fixes, small changes, and improvements to logging in 0.22, check it out!

Quilt Standard Libraries

Quilt Standard Libraries hasn’t seen any new merges since the update to 1.20.2 back at the start of October. The QSL developers are currently busy with school, making it hard to port Quilted Fabric API to 1.20.2+, and most open pull requests still need to be updated to the latest Minecraft version before they can be merged. If you’re interested in contributing, helping to update them is a great place to start. Althought QSL’s APIs haven’t seen any proposed changes, there is one new PR: Lambda has made a new licenser plugin based on quilt-gradle-licenser, and she’s opened a pull request to move QSL over to the new plugin. We’re still working hard on updating QFAPI to this new QSL release, and hope to have it done soon! We’re also considering making some changes to the structure of QSL and QFAPI to make the updating process quicker and simpler in the future.

Mappings

As always, QM has been updated to each and every snapshot this month, which includes 23w44a, 23w45a, 23w46a, 1.20.3-pre1, and 1.20.3-pre2. Though new mappings have been a tad scarce, we saw some important entity names from HyperPidgeon, and a few changes to item mappings by yours truly to account for the changes Mojang made to accomodate the Crafter. Along with those two small pull requests, I brought you full coverage of net.minecraft.data and Platymemo delivered a huge update to advancement mappings.

Since the main team is busy toiling away on Enigma’s 2.0 update, QM has lost coverage this month, going from 94.42% in the final 23w44a version to 93.15% in the current build of 1.20.3-pre2. Quilt Mappings development is incredibly simple to pick up, and anyone with experience developing Minecraft mods already has the knowledge needed to start mapping! You can read our blog post for more info about contributing to QM or go straight to our contributing guide to help!

Now: what is that 2.0 update that the team is so caught up with? Enigma is our deobfuscator, the program that we use to create mappings for Minecraft. It allows you to see and navigate Minecraft’s obfuscated code, as well as apply names you come up with. This month we’ve been working on the final improvements to its plugin system, shipping two big changes. First, Iota added new parsing features for profiles, with allow you to pass in data to plugins. In QM we use this to pass in information on Minecraft classes to our plugin. Iota’s pull request allows you to use a JSON list instead of an unwieldy string object, making parsing simpler for plugins and allowing JSON validation to act on lists.

Secondly, I worked on a huge pull request which overhauled the name proposal API, which allows plugins to automatically propose names for mappings. This means that an Enigma plugin is able to analyse compiled Java code, and guess — or propose — new names based on it. This is incredibly useful for repetitive code, and reduces the workload for the humans who work on QM. We also added tons of documentation, and a priority system that decides which plugin takes priority if two plugins propose a name for the same entry. Additionally, we fixed some crashes, squashed some bugs, removed some Recaf mapping format support, updated some other APIs, and cleaned up and documented internals as always.

Currently, Enigma 2.0 is in the home stretch! Iota is busy porting our plugin and refining the updates to the API, and I’m moving Enigma’s configuration backend to our own in-house Quilt Config API. Once those three items are complete, we should be ready to ship! Barring sudden disasters, of course.

Quilt Development Update: December 2023

Sun, 31 Dec 2023 15:00:00 GMT

Quilt Standard Libraries

This month saw just one new pull request on the QSL repository: an update to 1.20.2 by moe of mappings team fame. Neat!

While QSL development has remained quiet this month, the QFAPI cogs have begun spinning again, with two new pull requests: unilock’s 1.19.2 update, bringing our support up to FAPI 0.77.0, and Kneelawk’s 1.20.1 update, bringing Fabric API 0.91.0. That’s not all that’s gone on, however: our lovely OroArmor has continued to finalise the work on bringing Fabric compatibility to 1.20.2. The inside scoop is that the number of files with compilation errors has been whittled down from hundreds to just four, so make sure to show him some love for his hard work.

Quilt Loader

Loader has seen quite a bit of activity in the background this month, with the beginning of the betas for 0.22.1 as well the 0.23 release. Among the improvements slated for the next versions are improvements to debugging, expanded crash reports, support for Mixin Extras to match Fabric Loader’s recent implementation, new API methods, and of course tons of bugfixes.

Alex has also continued working in the background on the huge path retention PR, making tons of improvements. For a sneak peek, here’s the new set of user-friendly errors for unsupported mod files:

Quilt Mappings

As always, QM has stayed up to date with the latest versions, being ported to 1.20.3-rc1, 1.20.3, 1.20.4-rc1, 1.20.4, 23w51a, 23w51b this month. New mappings have been light, but the lovely moe came through with a bunch of new classes for you! We also got a new class courtesy of Kneelawk that came with the added bonus of fixing a game crash when breaking chests. The diverse ways that mapping issues can crash the game continue to amaze.

This has been a huge month for Enigma, the tool we use to create mappings, with the release of Enigma 2.0! Half a year in the making, this is our largest update to Enigma ever, or as I called it in the announcement, the greatest revolution in mapping technology since the last time we updated Enigma. Instead of giving you what we did on the update just this month, here’s the highlight reel of the whole thing.

In the backend, we’ve done some major reorganisation: the base package is now org.quiltmc.enigma, and we’ve moved every class into either an api or impl package. This means that you can trust we’re not going to make any breaking changes to functionality in the api package until 3.0! We also introduced indexing for mappings, meaning that just like how Enigma analyses JAR files to provide utilities, you can now do the same with mappings! Currently, we use this in the UI to tell you when a rename will create a new package. Finally, we did quite a few reworks to the plugin API, especially in the name proposal department. Now, the API is event-based, which means your plugin can provide names after two events: opening a JAR file, and when the mappings change. This took quite a few API changes, so make sure to read the full changelog if you’re interested in writing a plugin.

The command line got slightly less love, but nonetheless a few neat updates:

All commands now automatically detect the format of their input mappings: one less argument for you to write!
Errors and help have been improved: you can now run the help command to see all commands and descriptions of their function. Additionally, in the error message for a command, it will now show you all of its required and optional arguments, as well as descriptions of how to write them and what they do.
All commands now use kebab-case, making their names nice and predictable.

The user interface got the most updates here, with some major improvements to help you map faster. We’ve expanded the statistic system in the class tree: stats are now explicitly stored per-class, giving us the power to display stat icons on packages as well as classes. Additionally, instead of generating statistics for individual classes as they come into view, the stats for the full tree are generated at startup, making navigating the tree much snappier. Moving on to the code view, we added a new feature: the entry navigator. This consists of two buttons and a dropdown, which let you quickly navigate between entries of any token type. The token types are DEOBFUSCATED, OBFUSCATED, JAR_PROPOSED, and DYNAMIC_PROPOSED. For an example usage of this, instead of having to scroll through a big class looking for the one entry that you missed, you can simply switch to OBFUSCATED in the navigator and use the ctrl + down arrow hotkey to navigate to the next unmapped entry. For the final big update to the UI, we’ve moved over to Quilt Config, our in-house config library, for configuration. Your old config will not be migrated, and we’ve removed our old config library which was built into Enigma. The config now contains helpful comments and is sensibly organised into net, decompiler, keybind, main, and docker sections. Lovely!

There are tons more updates, including merging tons of changes from Fabric’s Enigma (thanks YanisBFT for giving us permission to steal them!), adding more tests and documentation, fixing tons of bugs, and piles of smaller changes we made to the backend and user interface. You can see everything in the full changelog!

Enigma continues to be developed, with 2.1 already on the way, fixing issues and adding yet more features. We’ve already ported our Enigma plugin and moved QM over to 2.0, so write some mappings and try them out!

Miscellaneous

First thing we did this month outside of the Big Three projects? Released the November update. We’re starting off strong with the release schedule of these posts. That isn’t the only thing that happened on the website this month: our brilliant Southpaw, who edits these posts, has been working in the background on updating its backing tech to the latest versions. Cozy, our discord bot, has been getting the same treatment, with sschr15 giving it an aptly named Big Update tm. For one last update to our Web Stuff, our developer wiki got an awesome PR from new contributor c-leri to support multiple languages and translate some articles into French.

To round things off, I dipped my feet into working on Quilt Config, adding some interesting new features to 1.1, which is currently in beta. It should be released out of beta soon!

Quilt Development Update: January 2024

Mon, 12 Feb 2024 15:00:00 GMT

As always, Mappings won the month, delivering two releases of Enigma and tons of changes to Quilt Mappings. Loader and QSL tried their best, but unfortunately can’t even come close to comparing to the glory of the Quilt Mappings suite of projects. Let’s get right into their pathetic attempts in the latest edition of Quilt Development Update: Unbiased Edition.

qsl

After a long few months in the mines, OroArmor has completed the port of Quilted Fabric API to Minecraft 1.20.2! Due to many, many technical changes in Minecraft, Quilt Standard Libraries, and Fabric API, it was an enormous task to tie them all back together in Quilted Fabric API. We’re sorry for the delay, and hope to find more help (perhaps you, dear reader?) and rethink the way QFAPI is set up so that we can update faster in the future! As with any big update, this came with a few issues, and we’ve continued to release new builds fixing them as soon as they come up. Next, on to 1.20.4!

Now, as a special treat, I’ve convinced our lovely new hire Up from the installer team to write up this month’s Quilt Loader section. While she’s absolutely brilliant in software development, she remains unproven in the blog post space. Make sure to email me regarding her performance if you find the following section unsatisfactory or would like to throw her a compliment for the excellent section.

loader

At least that was the plan. In a personal attack against me, Up’s internet tragically went down just before she was about to research and write this section. It’s still down as of writing. There seems to be some sort of cosmic force that prevents me from getting any help with writing these posts. Alas. Now let’s see what the loader gang was up to in January.

The main event of note was Up joining the installer team. Right at the beginning of the month, we finally pushed through a major cleanup of our new installer (which is not quite done yet!), written by the ironically named Rookie Coder. This clears the way for the team to continue working on getting the new installer as feature-complete as the old one!

Next, we wrote up an RFC and a subsequent implementation of sided mixins, a neat feature which allows you to better organise your mixins based on whether they apply to Minecraft’s client or dedicated server. Neat!

mappings

Mappings has had a big month this time around, thanks to Enigma 2.0 being pushed out last month, to excellent reviews from Enigma critics everywhere. One Enigma feature that has had the exact impact I hoped for in my nefarious plan is bright green checkboxes on fully mapped packages: to quote a new contributor, pyrox0, “Four easy checkboxes in the classes panel, I’m happy with that.” The QM team continues to innovate by creating new ways to make mapping more fun and therefore get mappers mapping.

Speaking of Pyrox, she has absolutely dominated the mapping scene like a rather prolific blizzard or perhaps an unusually furious snowstorm. It has managed to commit more than 2500 new mappings in just a month and only three PRs, which as a mapper myself is some fairly incredible output. However, she wasn’t the only thing happening in the QM sphere this month — let’s check out what the rest of the team was up to!

First off, Iota and I (rai minecraft) continued cooking up new Enigma goodness for you. At the very beginning of January, we released Enigma 2.1, a release mainly aimed at refining 2.0 but nonetheless featuring a few additions. Because we couldn’t help it. Firstly, we added two more development options: highlighting debug tokens in the UI, and showing the source plugin of automatically proposed mappings. This may not be exciting for you, the reader, but it allows us to more easily fix issues in the future! Speaking of issues, we fixed a longtime issue with interfaces: sometimes, a class could implement methods with the same names and signatures from two different interfaces. This would break the mappings if you renamed one of those, as Enigma wasn’t aware that they needed to match. Now they’ll be synced, making that impossible! And finally, we managed to sneak in a flashy feature: tokenization in the bytecode decompiler view, allowing you to more easily understand bytecode and rename tokens directly.

It also came with a huge round of bugfixes, since our team of two can’t catch everything before release. But on to 2.2! This one once again had a headline feature from Iota, hot off the tail of her bytecode view upgrade. The Enigma server, being the one component that didn’t get much love in 2.0, has finally gotten a facelift in 2.2. Among the main features are a rework to the way clients are approved which improves security, another development option (mwahaha) to log packets, streamlined code, and adding tests to keep everything running smoothly. It also comes with a new command: print-stats, which prints data about the total mapping percentages of the project. “But rai, none of these help you map faster!” I hear you screaming. Fear not, Enigma 2.2 brings more information in the identifier panel, telling you the parents of inner classes and — more importantly — the types of each parameter. This second one helps a lot for lambda parameters, which don’t clearly show their type like a regular one would. Now you no longer have to guess!

The Enigma sphere has one more thing to offer this month: Iota has been hard at work on the plugin once again, implementing recursive constant field search, delegate parameter name proposal, allowing strings passed to constructors to be used as constant field names, and cleaning up tons of code. This is one of the most technical projects in all of Quilt, so here’s a buzzword breakdown.

recursive constant field search: now, if a constant field is initialized using another constant field as a parameter, the plugin is able to see that field’s name and consider it as a name for the current field.
strings passed to constructors as constant field names: previously, the constant field name finder could use strings passed to methods to come up with names, but was unable to do the same when the declaring looked like this: new Thing("name") instead of createThing("name"). Lovely!
delegate parameter name proposal: we like to call this one “bubbling up parameters”. It’s similar to recursively searching for constant field names, but it’s now searching for parameter names. Occasionally in Java you’ll write an overload method, which means you’ll have a method like awesomeMethod(int value, int value2), where you usually want that second int value to be a constant value: let’s say 5. You’d write a second method, the overload method, that looks like this: awesomeMethod(int value) { awesomeMethod(value, 5); }. Now, thanks to some cleverness on Iota’s part, the value parameter name from the base method will now carry over to its overload method, as long as it’s unmodified.

Now let’s finally get into the actual mapping changes. As always, we updated to every snapshot this month: 24w03a, 24w03b, 24w04a, 24w05a, and 24w05b. Our coverage went from 92.76% in 23w51b to 94.62% in 24w05b, thanks to 21 pull requests from 8 different contributors! We had dreams of being able to say we were above 95% for this post, but unfortunately the latest snapshots knocked us down to 94 again. We’re always looking for new mappers, so feel free to open up a PR of your own or stop by the Discord any time. Here are the full stat differences:

This month was heavy on the new additions, with very few refactors to speak of. We’re continuing to work towards getting our completion up there with that of yarn again! Finally, our lovely OroArmor, QSL developer extraordinaire, came down from his throne to deliver a couple new features to Quilt Mapping Tools, our work-in-progress redo of the mappings toolchain.

misc

After about eight months without getting any features (*unikitty voice* emmmbarrassing!) Quilt Config, our solution to the Minecraft config library disaster, defrosted thanks to some hot new additions with its 1.2 release. The motivation of these additions, mostly made by a certain rai minecraft you may have heard of, was to get QConf working outside of Quilt Loader to be used as the config backend for the aforementioned Enigma 2.0. Mission success! Let’s look at what it took:

instead of expecting programs using QConf to provide their own serializers (the programs which take config values and read and write them to config files), it now ships with two default options for the TOML and JSON5 formats. This solves what was, dare I say, a pretty stupid situation before where Loader had to directly copy the code of the serializers used in QConf’s unit tests for use in production. An additional benefit of this is that features that depend on serializer changes, such as one we’re going to talk about next, no longer require programs using QConf to manually update their serializers. Instead they can just import the updated versions directly!
I leveraged Quilt Config’s powerful metadata system to set up a new annotation: @SerializedName. A mainstay in serialization libraries like GSON, this allows you to manually decide the name your config field will take in the serialized file instead of having to use the name from your code. For an example usage, you could name a field in your code superCoolField and then serialize it as super_cool_field, to conform to both Java and TOML name conventions at the same time. Thanks to the heavy lifting of implementing this, we already have some new ways you can customise your config files coming in 1.3!
While building those updates, I ran into a few high-profile issues that needed fixing. These are now fixed!
- The metadata on config sections used to be ignored, meaning that you couldn’t give them custom serialized names, comments, or any of Quilt Config’s other handy pieces of metadata. Unfortunate.
- Adding dots to a key when saving to TOML was completely broken and would produce an unreadable disaster in the config file. Thanks to the lovely hibi for finding this one!

That’s not quite it for Quilt Config. I’m working on comprehensive tutorials for the developer wiki on how to use Quilt Config! Now we’re done.

Our template mod got a nice little update in the form of deduplicating the maven group value between the gradle.properties and quilt.mod.json files, the same way the version is synced. Thanks to TheKodeToad for that!

One of our other little-loved projects got pull requests this month: Quilt Parsers, the backend JSON parser for everything Quilt, has a couple minor improvements in the words thanks to Leo! Delightful. We’ll see you next month!

Quilt Development Update: February 2024

Sat, 09 Mar 2024 15:00:00 GMT

Quilt Standard Libraries

It was barely one day into February when I was told that the registry sync system in QSL was running too late. This lead me on a wild chase as I hunted down and squashed the bug, upgrading QSL’s configuration networking API in QSL PR #363. Later in the month, I went on another bug-squashing adventure, quickly taking out #364, #365, and #358 for 1.20.2.

Now, I bet a lot of you are wondering when I will get around to QSL for 1.20.3 and 1.20.4. I understand its been a while, but I am very busy. UNTIL NEXT WEEK. (editor’s note: Mr Armor is always saying this. Take his words with a grain of salt)

That’s right, a new QSL update is coming soon to a Mod Hosting Site near you! Hurry up, only while supplies last!

Quilted Fabric API

As for the other half of Quilt’s APIs, QFAPI was updated with the latest QSL version, making sure that you get those bug fixes. In addition, there were a few sync pull requests that brought older versions of QFAPI for 1.20.1 and 1.19.2 up to date with the latest Fabric API for those versions. Thanks unilock and Kneelawk for these updates!

Quilt Loader

Back to your regularly scheduled writer. Loader has mostly been getting minor fixes and keeping synced with Fabric compatibility this month, in preparation for a bigger release coming in March! This includes some improvements to error readablity for users, fixing compatibility with a few mods using Fabric Loader internals, and work towards the stabilization of loader plugins. As I write this, it’s March and the release has come out. Because I’m mean, you, dear reader, will be told about it next month!

Quilt Mappings

As always, your favourite team has delivered day 1 updates for every snapshot: 24w09a, 24w07a, and 24w06a this month. Let’s hit the highlights in terms of pull requests. Realms screens as well as particles have once again hit 100% completions thanks to work from Iota and pyrox, and we’ve seen lots of new coverage in snapshot features like trial spawners and world events. Despite the valiant efforts of our mappers, we’ve lost 0.5% coverage this month. A single perfect tear rolls down my smooth, emotionless visage.

To discuss something other than coverage for once, we’re planning to go ahead with a major change to QM in the future: matching Mojang’s package structure. Note that we’ve hardly started on the implementation of this change, so it’s still very much to feedback from the community (including you, dear reader!). This means that while QM will still define its own package names, all classes will be organised in the same packages as they are in Mojmap. This allows for a few major benefits:

It gives us the ability to map package-info files, which allow giving more context to users as to what an overall package is meant for.
By mimicking Mojang’s structure, we allow QM names to be more future-proof: instead of deciding our own names which may be contrary to Mojang’s intentions, we follow their vision for the code exactly. This prevents situations where mappers organise things one way, and via game updates it becomes clear that Mojang intended the classes to be organised in a different manner, forcing us to refactor names.
QM mappings will become more familiar to modders accustomed to using Mojmap.
It eliminates the necessitity of remapping class access rules: QM’s arbitrary former package structure meant that package-private elements could be put in any package, meaning that tooling would have to edit those access rules to make sure they functioned the same as an unmapped game. Without this step, it’s easier to implement QM on platforms such as Neoforge that are moving to Mojmap-only.

And finally, Enigma has of course been getting some love throughout the month. We’ve fixed a pile of bugs with version 2.2.1, and started work on some features for 2.3! 2.2.1 brings fixes for:

Improper syncing of javadocs on the server
A couple crashes
A few false positives in the mapping uniqueness validator
An edge case where valid Java code could be rejected
The “decompile inner classes” Vineflower options causing decompilation failures

And in terms of features we have cooking, the ctrl + f quick find dialogue has been updated and we’ve stolen yet another feature from IntelliJ: the progress bar in the corner. More details will come in next month’s post!

Miscellaneous

Developer Wiki

The Quilt Developer Wiki got not one, not two, but three new articles this month, thanks to a rather enormous pull request from yours truly. These articles are:

Getting started with Quilt Config, an overview of the most important features in Quilt Config and how to use them. It includes how to set up a config in a Quilt mod, how to add values, using annotations to add metadata, and saving values in maps and lists.
Advanced configuring, an article that goes into all the gorgeous features of Quilt Config that you don’t need for a simple configuration. However, for those storing complex values in the config or making large configs, this is a must-read! It goes into detail on serializing custom values outside of basic types, maps, and lists, as well as giving details on using the powerful processor feature and organising your config into separate sections and files.
Annotation and metadata reference, a reference on all the different annotations Quilt Config allows you to apply to your configs, sections and fields. It currently includes:

We’ve also updated the url to wiki.quiltmc.org (from modder.wiki.quiltmc.org). The original idea behind the frankly grody old domain was to create an entirely separate wiki on user.wiki.q.o that was targeted specifically at users, to provide install information as well as tutorials for features like dependency overrides. We’ve decided that an entire dedicated domain is a tad overkill for the few tutorials that would be written for it.

Quilt Config

Quilt Config has seen the merge of a few minor pull requests this month, with some bigger ones in the works for a future 1.3 release! Processors have gotten a pretty big update, getting full documentation and the ability to apply to sections, in addition to the fields and classes they could already work on. We’ve also removed some nonsense comments bloating config files with custom serialized values, added a new shortcut method to allow you to more easily set values, and fixed up some problematic Javadoc.

Quilt Loom

Quilt Loom got updated to the latest Fabric Loom. Cool! Oro did this, so I probably should have made him write the section. As resident mappings girlie I hardly write mods and haven’t used this. Burn me at the cross now. It’s mostly about performance, with the headline feature being the way Loom remaps mixins being brought in line with the way everything else is remapped, for better consistency, more buglessness, and performance.

Quilt Kotlin Libraries

Quilt Kotlin Libraries has followed QSL in updating to 1.20.2! It also fixes a few old bugs and new bugs. Have fun!

At last, that’s it for me. See you next month quilters. Keep slaying.

Quilt Development Update: March 2024

Mon, 08 Apr 2024 15:00:00 GMT

Quilt Standard Libraries

Despite not officially being on the program today, OroArmor has been hard at work updating Quilt Standard Libraries and Quilted Fabric API. This time, they’ve been updated to 1.20.4, squashing countless bugs, including one from 2021! In addition, he squeezed in a rework of the Recipe Remainder API.

In the old Remainder API, there was a long-standing bug which allowed duplicating items in a few mods. This would happen when smelting a water bucket to create an item like Modern Industrialization’s Steam Bucket: while the mod relied on the vanilla behaviour of the furnace input being destroyed, the QSL API erroneously saw a bucket being destroyed and assumed it should be kept as a remainder. Since the recipe creates a new bucket as output, this would result in smelting a water bucket giving you a bucketful of steam as well as an empty bucket left behind. The new version of the API solves this by requiring mods to explicitly state that they’d like to leave a remainder when it wouldn’t follow the vanilla behaviour.

Quilt Loader

At the very beginning of March, the Loader team satisfied the Minecraft community’s eternal hunger for updates by delivering a major upgrade. There are headlines here for both users and developers! First off, here are the new treats that users are getting.

The dependency error interface has been updated to be much more human readable for lists of versions. No longer do you need to take pre-calc and understand that version range [0.5.7, 0.5.7] U [0.5.8, 0.5.8] means you need either version 0.5.7 or 0.5.8. We’ll instead simply display a list of versions: version 0.5.7 or 0.5.8.
We’ve added a new startup screen which shows mods that Quilt Loader cannot load. Currently, it’ll recognise Neoforge, Forge, or Risugami’s Modloader mods, and inform you what’s going on.

Now let’s get to the fun bit: the API stuff! Loader plugins have taken a huge step towards stability with the merge of the path retention system, which means that loader retains information on files and folders after finding them, allowing plugins loaded later to still scan those files and folders for mods. In terms of the non-plugin API, many GUI classes have been moved to the public-facing API, allowing the few mods that need them to work with Quilt Loader GUIs.

Additionally, you may have noticed that a new project has cropped up under the Quilt GitHub organisation: Quilt Loader Bootstrap! This new project will, in the future, allow Quilt Loader to update itself, saving you a trip to https://quiltmc.org to go grab an installer file to run every time you need to update Quilt Loader. It solves the issue of adding Quilt Loader and its libraries to be added to the Java classpath after launch, the main blocker to allowing painless updates. Its README file has more information!

The loader team is already hard at work on the next updates!

Quilt Mappings

Like a glorious phoenix, Quilt Mappings’ completion of Minecraft has risen 1% this month. Well, 0.95% to be exact. But let me have this, ok? Let’s start with the beautiful imagery.

Now I know, looking at that image, your first thought is “how, pray tell, has Quilt’s creme de la creme in terms of developers managed to achieve this feat?” An understandable question, dear reader. Over 24w10a, 24w11a, 24w12a, and 24w13a, nine pull requests have been merged adding new mappings, as well as two refactor pull requests! These pull requests were all made by myself, supersaiyansubtlety and pyrox0 in a truly incredible run that we’d rather not repeat this month. If you’d like to help us increase our coverage, our CONTRIBUTING.md is a great place to start!

The most notable achievements this month are completing mappings of Mojang’s new item component system added in 24w09a, completing mappings for entities. We’ve also added tons of new mappings in areas such as networking, screens, datafixers, potions, and more!

Enigma got quite a bit of minor work as well this month, working towards the release of the 2.3.0 update. The highlights are:

an improved for look for the ctrl + f quick find dialogue
cleaned up information in the identifier panel
fixing desyncs between the entry navigator and the actual mappings
the merge of 2.3’s major feature, the new progress bar which indicates what enigma is doing in the background as you map

Stay tuned for the release, coming soon! You know it’s actually coming soon because it’s me saying it, and not Oro.

Miscellaneous

Lots of work has been happening on smaller Quilt projects this month, with the website, the developer wiki, Quilt Config and Quilt Loom getting attention.

First, there’s a new page on our website! The changelog page is here to save you from needing to sift through Discord and GitHub to find changelogs for Quilt projects. Currently, it supports Enigma and Quilt Config, and will be updated to include more projects and more versions in the future! It automatically updates as new changelogs are written for each project. Eventually, we hope to include every major Quilt project on this page! In addition, we’ve reorganised the install page and updated it in order to reflect the release of GDLauncher Carbon, the latest launcher to add support for Quilt.

The developer wiki has received a big update thanks to celeri, who translated every single page to French! We also reworked the “Creating your first item” page in order to be more clear and useful.

Finally, Quilt Config got tons of work towards its 1.3 release and Quilt Loom was updated to pull in Fabric’s changes in Loom 1.6! Thanks for reading, and I’ll be back with more updates next month. You can’t stop me. Many have tried.

Quilt Development Update: April, May & June 2024

Tue, 02 Jul 2024 23:00:00 GMT

Quilt Loader

As always, our beloved Alex has been cooking up endless amounts of features and fixes for Quilt Loader. We released two major updates in the past 3 months, 0.25.0 and 0.26.0!

Starting things off, landing in 0.25 is a feature by a new contributor, Mega! This is an annotation built into Loader that allows stripping code from your mod when another mod is not detected. This is an easy way to improve compatibility with other mods that don’t implement their own entrypoints. To parrot the example from Mega’s PR description, this is usable to make an item a trinket only when that mod is loaded:

public class MyOptionalTrinketItem extends Item implements @Requires("trinkets") Trinket {
	@Override
	@Requires("trinkets")
	public Multimap<EntityAttribute, EntityAttributeModifier> getModifiers(ItemStack stack, SlotReference slot, LivingEntity entity, UUID uuid) {
		// code that will only exist in the mod if Trinkets is loaded!
	}
}

When using this annotation, be careful to always test in production without the optional mod in order to ensure you properly stripped all references. This release also contains some minor features and fixes, such as providing the reason in inter-mod breakage errors.

Moving on to 0.26, we have a release more geared towards backend improvements than new APIs for mod developers. The lovely Lukebemish contributed a rework of how Loader manages its dependencies, making it much, much easier to depend on Loader outside of Loom. Another new contibutor, voidpointer, added a new commandline parameter, -Dloader.ignore_unsupported_mods=true, that allows ignoring the errors for mods in the mod folder that cannot be loaded by Quilt. This release also makes two improvements to crash reports, which the changelog will tell you about:

Include the zone offset (raw time number like +0100) in the actual crash report file. This should help when assisting people in other timezones, as we can figure out how recently a crash report was generated.
Change from CLOCK_HOUR_OF_DAY to HOUR_OF_DAY. This means we’ll get digital time at 15 minutes past midnight (00:15) rather than analog time (24:15). Of course, this release also comes with some important bug fixes and minor changes. Which I would love to talk about. But corporate tells me I’m consistently exceeding my word budget on these posts, so on to another update under the Loader umbrella: Quilt Config!

Quilt Config

Right at the beginning of April, we released Quilt Config’s biggest update ever: 1.3.0! Quilt Loader has already updated, so all these features are already available to use in your mods as of Loader 0.25.0. The main highlight of this release is five new annotations, but we’ll get to those in a second. Firstly, we solved two big issues with using 1.2:

The deprecated WrappedConfig system had some major flaws (on top of the ones that make it impractical and deprecated!) related to using simple types like String. Compiled code in Java will inline references to constant values (those prefixed with final), meaning that the hackery we did to change the values in the code according to the ones read from the config wouldn’t always work. The inlined usages of those variables are no longer references, they just directly pass in the original value, ignoring what was read from the config file. We now allow using non-final fields in WrappedConfig configs, and print warnings when fields are final. This will resolve that issue, but make it easier to misuse the system and cause unexpected behaviour. We highly recommend using ReflectiveConfig instead.
Processors were undocumented (besides on our lovely wiki) and didn’t work consistently. We’ve now added extensive Javadocs and fixed them not working on sections to make their behaviour more predictable.

Now for the exciting part! Composing the five new annotations in this version are:

@SerializedNameConvention: this allows you to define a convention for automatically converting your field names to a specific casing for serialization. The most common use case for this is to convert the camelCase of your Java field names to the snake_case that is the TOML convention. You can apply this to every field in a class with just one annotation!
@Alias: this annotation, in addition to being cutie baby, allows you to change the names of elements in your config while maintaining backwards compatibility. Note that there is no mechanism in Quilt Config to migrate the type of your field (yet!) so this will only be useful for direct name changes.
@ChangeWarning: allows you to define how destructive changing a specific config value will be: gives the options of RequiresRestart, Unsafe, Experimental, and Custom (with CustomTranslatable also an option!).
@DisplayName and @DisplayNameConvention: allows you to define a nicely formatted name for your value, to be displayed to users. Supports translations!

Those last three annotations have no real functionality in Quilt Config: you’re simply defining more information to be attached to your config field as metadata. Quilt Config 1.3 is a huge step forward in terms of establishing the APIs and annotations we need in order to build a mod that will use that information to automatically generate config screens for all mods using Quilt Config. If you’re a real Quilt Config aficionado, make sure to check the full changelogs for 1.3.0 and 1.3.1 to see all the smaller changes we made!

Quilt Standard Libraries

QSL has received quite a bit of attention in the past few months, both on released versions and the work-in-progress ports to 1.20.6 and 1.21. 1.20.4 got two minor features:

A new event for when networking configuration is complete and ready to move into the PLAY phase.
An option to reserialize custom packets, fixing edge cases with networking compatibility compared to Fabric API. Coincidentally, Mojang have implemented this same functionality in Minecraft 1.20.5+, which means we’ll be able to drop this hackfix in future versions. Which is cute for us. Not that you care.

We’ve been hard at work with the ports, and I’d like to use this post to explain part of why ports of Quilt Standard Libraries take so long. As you probably know already, we simply have less developer time available, making it more difficult to keep up with Mojang. However, that’s not the only reason we release API much later than other loaders. Instead of prioritising maintaining the same API surface between Minecraft updates, our philosophy is to break as much as we need in order to make a more elegant API. This allows developers to better understand the way Minecraft’s systems work, through molding QSL’s APIs to Mojang’s changes. However, reworking APIs takes time, and right now it’s yet another barrier to quickly releasing updates.

This release schedule makes it very difficult to develop mods using QSL, so we’re making a few changes to the process. Instead of creating a monolithic port to be released all at once, for future versions we’ll be releasing QSL module-by-module, to ensure that developers have something to work with as soon as possible. Using this system, we’ll be able to release core systems such as entrypoints day one. Until QSL is fully ported, unported modules will be disabled and unusable by mods. We’ve begun doing this with a core-only publication of QSL for 1.20.6.

Quilted Fabric API

Moving on to QFAPI, we’re also making major changes over there. Instead of a system where we maintain a full fork of the FAPI codebase, we’re moving over to maintaining patches that will apply to the original codebase. Previously, for each update to the FAPI code we had to fight with git merges in order to get the new code into our parallel project. Each time we did so, we were adding commits and confusion to the git tree, making the next merge an even harder project. With patches, we’ll have the much easier job of updating any out-of-date patches with each update to upstream FAPI instead of dealing with hundreds of files needing merge attention. Progress has been steady on this new system, and we’re just as excited to have an easier time updating as you are to get faster updates.

In terms of actual releases and not just work-in-progress stuff, we’ve done a few updates! To shorten a lot of work (a lot of fighting with git) into just a sentence, we released 1.20.4 and synced it up to FAPI 0.97.0, as well as updated our 1.20.1 version to FAPI 0.92.2.

Quilt Mappings

It’s been three months since we last updated you on the state of Quilt Mappings. Perhaps that lack of blog attention combined with a slight lack of maintainer attention is what’s caused this drop in percentage. Either way, don’t linger too long on my shame. We’ve lost nearly 1% in the last 3 months. At the very least, we’re gaining once again as of 1.21! Contributions are always welcome, and Quilt Mappings is one of the easiest modding projects to hop into and start helping with. Check out our CONTRIBUTING.md to get started!

Enigma

Now on to my child. The software behind it all. Enigma. We made three enigma releases in the last few months, with two big updates and a bugfix release!

Starting with 2.3.0, we put out an update composed of mostly small features. We added some UI garnish, with a corner progress bar telling you what’s going on in the background, more info in the info panel, and info on dockers when they’re inactive instead of just an empty panel. For info lovers, this one’s a treat! We also made lots of bugfixes, updated dependencies, and added a couple new config options. Then 2.3.1 was released because the updated ASM dependency was a pinned snapshot that expired. Oops.

After relaxing with a mostly-UI update, for 2.4.0 we went back to the backend and broke the API. The main change here was moving reading and writing mappings into services, which are defined by Enigma plugins. We did this in order to abstract out reading and writing, so that we can add support for different methods without continuing to complicate the internals. We’ll be using this in the future to add Mapping-IO support. With this comes new features like active-by-default services that bypass the need to enable them in the profile, filters for the “open mappings” dialogue in the UI to make it easier to search for mappings, and validation for lambda parameter names. That last one is important — lambda parameter names previously had no validation, but now it’s impossible to introduce clashes between parameter names using the UI! And of course, we fixed tons of bugs, added more little features, and updated some dependencies.

And we’ve still got one more thing to share with you! Quilt Enigma is being tested out by Parchment, another mappings project for Minecraft. Parchment takes Mojang’s official mappings, and adds parameters and Javadoc to make it more usable. Parchment is a great project, and we’re glad that we can help them out with our tooling!

quiltmc.org

In the last few months, the website has received quite a few updates! We could go in chronological order (yuck, boring, been doing it all post) to see the additions but I think it’s more fun if we take a little tour.

Starting off in the top bar, you may immediately notice a big change: there’s a search bar now! This search bar uses the lunr.js backend, and allows you to search for any page on the site. As the dropdowns continue to expand with more and more pages, I’m glad those who don’t spend 25 hours a day on https://quiltmc.org like me will still be able to find their way around.

Moving along the top bar, you may notice that the usage dropdown has grown in size a bit. Firstly, we’ve created a dedicated page for known QFAPI incompatibilities. This page lists off all mods that work when running Fabric API, but not Quilted Fabric API. If you’re using QFAPI and run into issues, this is the first place to check! But let’s move on. We’ve been busy, and there’s more to look at on the website.

On the sidebar, there are now five items where there used to be two! We’ve just gone over one, but there are still more new pages to see. Firstly, we’ve created an official import utility for finding the latest versions of each Quilt project for a given Minecraft version. We previously had an unofficial utility maintained by LambdAurora, and all the same features that utility had have made their way to the official website. Finally, the biggest new addition: the mod generator! This page, similar to the one recently launched by Fabric, automatically customizes a mod template, so that you can just download and get right into modding. No more fiddling with renaming directories and messing with metadata before you can get up and running!

That’s about it for the exciting new things, but thanks to the work of contributors like Up and Pyro, we’ve done plenty of updates to our existing pages and maintainance to keep the website running smoothly. Finally, while being a lovely engaged reader and clicking the many cute blue hyperlinks I’ve been feeding you, you may have noticed a small quirk of our website: right now, absolutely nothing has icons. We previously had a paid subscription to an icon kit, FontAwesome, but are now in between icon sets. Let me know if you like the new, weird-blank-space-abundant layout. I think I might push to keep it.

Quilt Developer Wiki

If you turn your attention over to our wiki, you’ll also notice a few new things! We’ve written up a beginner’s guide to understanding and contributing to Quilt Mappings, and as per usual rewritten some sections of the other pages in order to increase clarity. We’ve also finally added a proper landing page, giving our work-in-progress wiki the beginning of that finished project shine! Monthly reminder to thank c-leri for doing much of the backend work to keep the Quilt wiki running.

Quilt Infrastructure

Quilt’s infrastructure has been, to be nice and pretty much give our servers a pat on the head and a good job, not working very well for a long while now. We’ve kept everything up (except the forum!) and reliable, but behind the scenes things have been pretty messy. In the last few months, our infrastructure team has been cleaning everything up in the background, as well as making sure that our infra won’t become a disaster for a second time.

We moved to the platform Argo CD for continuous delivery, which is fancy way to say keeping everything running all the time. We’re using Argo CD for a few reasons:

It allows us to monitor and interact with resources on our servers through a nice user interface, diminishing the technological wizardry we have to go through on a regular basis.
It allows us to define granular permissions, which we can use to allow teams who don’t have access to all of our infrastructure to run maintenance like updates and restarts on the projects they work on.
In general, it allows our deployments to be more reproducible and explictly defined, helping with the aforementioned keeping infrastructure from falling apart.

Moving on to updates our lovely users actually benefit from, the Quilt Forum has been brought back from the dead! Now that it’s up and running again, we intend to post to the forum more often with changelogs and blog posts like this one! This took a lot of work, and we’re still finishing it up: as of writing, the forum is readable, but not everyone can make posts yet. The full forum should be ready soon!

In order to prevent another long period of downtime for the forum, we’ve set up regular backups of all our databases. We’ll be able to quickly restore one of these in case of another hardware failure like the one that took down the forum last time!

We also cleaned up the way we deploy new versions of our Discord bot, Cozy, and gave her a little more memory to work with to make mappings lookup more reliable. Finally, we’ve moved all of our servers with sensitive data (such as Modmail), over to providers in the European Union. This guarantees we comply with the GDPR privacy laws to protect your data.

And that’s everything big that we worked on in the last few months! Come back next month for a hopefully-on-time July update.

QSL and QFAPI for 1.20.6 and beyond

Wed, 03 Jul 2024 20:00:00 GMT

More importantly, however, you may have noticed that this is the second blog post in two days! That’s not even enough time for Eminem to write another song. This is because rai (your usual blog post correspondent) now has competition! If she doesn’t turn in the next monthly blog post on time, I’m replacing her with an AI trained on speeches given by members of the Canadian Parliament. What could go wrong?

the meat of the story

On a more serious note, you may have noticed that 1.20.6 has been out since late April, but QSL and QFAPI had (until this blog post) still not updated. And this has been a problem stretching all the way back to 2022, when QFAPI was first released. I want to take some time to describe why we’ve had so much trouble updating, what we’re doing about it now, and some ideas we’re considering for the future.

why things have taken so darn long

QSL updates are slow for a few reasons. For one, it’s huge! It spans several very complex problems that normal modders don’t need to think much about, like the internals of networking, synchronizing registries, and loading mod-provided resources. Additionally, these huge APIs touch parts of the Minecraft codebase that are refactored by Mojang all the time, meaning even an update like 1.20.4 to 1.20.5 might require a rewrite of half the networking module.

Another hurdle for porting QSL is that its APIs must be implemented in a way that is compatible with QFAPI. This means that we not only have to design a new API that elegantly represents how the internal Minecraft code changed, while still being similar enough to Fabric that we can maintain compatability.

But perhaps the biggest problem with porting QSL is that these complex APIs are really old! The original contributors for these APIs, who intimately understood how they worked, have moved on from Quilt. That means that our “new guard” of core maintainers, who didn’t write the now-broken APIs, have to learn how they work as we try to fix them, which is slow and very error-prone.

what we’re doing about it now, or “how i learned to stop worrying and love fabric api”

Clearly, QSL in its current form is not sustainable, and we’re going to need to do significant work on it so that it can be updated quickly. However, we lack the contributions to both work on a rewrite of QSL and keep the behemoth old QSL updated. So, in the meantime we’re going to distribute an extremely stripped down version of QSL. Currently, that means only qsl_base, the module that provides entrypoints and an event system, and crash_info, so that crash reports are still Quilt-y. Quilt modders looking to port to 1.20.6 and beyond should migrate their use of Quilt APIs to the relevant Fabric equivalents for the time being.

If you are a Quilt modder who relied on a Quilt API with no Fabric replacement, please tell us! We want to prioritize providing APIs that modders actually use, so please open an issue and let us know.

moving forward

Stripping QSL like this is meant to be a stop-gap solution to keep things moving along while we fix the underlying issues with QSL. We aren’t sure exactly how things will change in the future. We may eventually restore all the old QSL APIs and continue business as usual, remove some modules which unnecessarily share code with Fabric (like networking), or even move to QSL being only an extension on Fabric API.

No matter what happens, our first priority moving forward is to ensure that Quilt Loader users are able to play with their favorite mods on new versions as soon as possible.

Bringing Quilt into the non-obfuscated era

Tue, 03 Feb 2026 20:00:00 GMT

A bomb has been dropped on the modding community: In October last year, Mojang announced that, beginning with the snapshots for Minecraft 26.1, Minecraft’s code will no longer be obfuscated. For those who don’t know what that means, for Minecraft’s whole lifetime its code has been “obfuscated”, or scrambled to make it more difficult to read. From 26.1 onwards, modders will have access to the complete, unscrambled code that Mojang developers do, which is a fundamental change for how mods are made. Until now, projects like Mod Coder Pack (MCP), Quilt Mappings (QM), and Yarn have provided “mappings” to make the obfuscated code readable, and Mojang even offers a set of mappings themselves. However, now that the code isn’t obfuscated in the first place, mapping projects are no longer needed. Thus, it is with heavy hearts that we, the Quilt admin team, declare that Quilt Mappings will no longer be maintained for new Minecraft versions. But also YAYYYY more time for other projects! This post is an overview of the changes we’re planning to make to Quilt so that we can move into the non-obfuscated era with our characteristic poise and elegance.

Quilt Mappings

As we stated in the intro, QM will not be released for any future versions of Minecraft, although we will still accept contributions for older versions. This doesn’t mean that mapping projects as a whole are over, though! We sort of lied when we said that the mappings are complete. They’re missing one important aspect of the code: the developer documentation. The Parchment project intends to continue releasing documentation for newer versions, and you might just see a few of our team members helping out there.

Those more familiar with mappings will know that we spend a lot of time building software and libraries to help us keep up with Minecraft’s constant updates, and the end of QM doesn’t mean the end of all that great work! Our technology is still going to be used in documenting Minecraft, legacy modding projects, and even mapping efforts outside of Minecraft, so we don’t intend to let QM’s software ecosystem die with it. Even beyond user numbers, the team is passionate about our software, and we want to keep building it. The primary project for the Mappings team will now be Enigma, the program we used to make mappings for Minecraft. Enigma’s development has been going strong since Quilt was born, with our huge version 2.7 having just come out and the possibly even bigger 2.8 in development right now.

Unfortunately, the story isn’t quite so happy for the rest of our mappings tooling. Much of it is no longer worth maintaining in an un-obfuscated world, such as our version of Unpick that was forked from Daomephsta and Fabric’s original. We’ll be archiving all of our smaller forked mappings libraries like Unpick, Stitch, Tiny Remapper, and more. Our original work, such as Hasher and Javadoc Draftsman, will go into maintenance mode for the foreseeable future, receiving only important fixes. Our experimental, unfinished replacement for much of the Mappings tooling, Quilt Mapping Tools, will no longer see any new work from us either. For those who used the tools listed in this paragraph, this shouldn’t be a big surprise. None of these have received major updates in the last couple of years, and we’re largely just formalizing the status that these projects have been in for a long time.

Quilt Standard Libraries and other APIs

Quilt maintains 3 different API mods for Minecraft: Quilt Standard Libraries, Quilt Kotlin Libraries, and Quilted Fabric API. We (your hardworking admin board) have decided to officially retire all three of these libraries in Minecraft 26.1. However, they will still receive maintenance updates on older versions, and we are investigating porting some their innovations we made back to Fabric API so that they can be used by more modders. We have two main reasons to make this change. Recently, the work to maintain these libraries has largely fallen on one sole developer, Oro (everyone say thank you oro!), who has been unable to commit enough time to make sure that they are quickly brought to newer versions. Secondly, the design of QSL as incompatible with FAPI, which allowed us more space to innovate and make more powerful APIs, has proven to be extremely difficult to maintain long-term. Our compatibility layer between the two, QFAPI, is confusing for users and cumbersome for developers, leading to slow updates and users dropping off Quilt. This has been the state of Quilt’s libraries for long enough that we’re officially retiring them in order to make Quilt more user-friendly.

We still believe that our libraries are great projects that succeeded in their goal to innovate and improve the modding ecosystem, and we’re happy with the work we did. Nonetheless, they have served their purpose, and we’re excited to focus on other aspects of Quilt.

Other Projects

Several of our other projects are going to see some changes as well. We are officially retiring the CHASM project, our concept for a more conflict-resistant system for modifying Java code. While it has seen a lot of progress in its implementation, and a prototype is working, enough of its use cases have been covered by an alternative project, MixinExtras, that we’ve decided to stop looking for a developer to finish the project. There were a few core flaws in its design (you can read this post by a former Quilt developer if you’d like to learn more!) that made completing the implementation extremely difficult, and we’d rather help to improve the existing tooling than continue with CHASM.

Our developer wiki is also going to see major changes. We originally envisioned a system where articles would be written with code from real, automatically tested projects, guaranteeing that the code was valid and up-to-date for the latest version of Minecraft. Now that we are no longer maintaining version-dependent modding APIs, the benefits of such a system are far more limited, so we plan to migrate to a simpler and more accessible wiki that’s better integrated with our main site, using more standard frameworks and less original code to simplify development. This new wiki will be the central location for all documentation on Quilt Config, Quilt Loader, Enigma, and more. Work hasn’t yet begun on this move, but contributions and ideas are always welcome!

In terms of our community, we’ve been working on a refresh to the website to go along with this announcement. That new website is live now, including rewritten documentation, a new homepage, and more! We’ve been working on this in private for a while, and we’re excited for you to see it. We would also like to announce that our previous keyholder has stepped down from the role for personal reasons, and the admin board and community team have elected to retire the old version of the role and give keyholder duties to an Admin Board member instead. The new keyholder will be Rai, as you may have noticed from the little crown beside her name in our Discord server.

Quilt Loader

Finally, let’s talk about Quilt’s flagship project, and one that is only going to be receiving more attention in the future. Our goal for Quilt Loader is to make it a modern, user-friendly loader that makes sense for users who have never played modded Minecraft before. Let’s talk about how we’re planning to do that! There are two key areas of friction for new players: updates and crashes.

The first issue is updates. For a user, there is generally no reason to update their loader unless the game crashes. In that case, they have to decipher the error to figure out that an update is needed, and work out that in order to update they have to return to the installer and overwrite their current version. This means two things: most users aren’t getting access to our new features as we update Loader, and users are confused and frustrated when a crash forces them to update.

Our solution is simple: implement an optional automatic update checker that will let users know when a stable version is out, and be able to update loader without interrupting your game launch or forcing you to interact with the installer. We’ve already laid much of the foundation for this feature, and we welcome any feedback you might have!

The second issue is game crashes. For a lot of users, modded Minecraft is their first exposure to a program crash, and first time they see a stack trace. We want QLoader to help users understand the crash (something we’ve already put quite a bit of work into with solver improvements and GUI updates!), and in the future we want to allow the loader interface to help you fix crashes. We’ll be offering at least two solutions to common crashes in the UI:

Offering stable or beta updates to loader when it or Fabric Loader is out-of-date. This will be simple once we get our automatic updating working!
Creating overrides to fix dependency issues, making sure that overrides are obvious in the UI and logs to avoid users sending error reports for mods they’ve overridden. We also have a couple more ambitious ideas, which may or may not end up in Quilt Loader. We want to make sure we get them right! Here are a few of them:
Disabling mods involved in the crash
Offering updates to mods involved in a crash, and possibly dependencies (remember that a very large group of users are on the vanilla launcher, and there’s no Prism reminding them), with a quick one-time warning to ensure the user understands that they’re downloading unverified third-party software
And more! These are just a few simple ideas, and there’s lots of potential for Loader to non-destructively make attempts to diagnose and fix crashes, and we’d love to hear more feedback. Our goal isn’t to fix every crash automatically, but we want to simplify mod management for more knowledgeable users and help newer users learn to fix simple crashes in a more intuitive way than being expected to read pages of documentation. If we can fix just a few crashes using these methods, those are a few users who are having a way better experience playing modded Minecraft!

Beyond this, we have a few long-awaited features we continue to work on for Loader, such as our Loader Plugins system for allowing developers more control over Loader’s behaviour (there are already some interesting plugins in the works, like Quilt Bisect!). Keep in mind that we’re volunteers, and we develop this project as a passion, not as a job. We won’t be committing to release dates for anything mentioned in this post, but we’re always working to get new features out for you, our beloved players and developers. See you soon!

The Quilt Project

This is Quilt

Why the Fork?

Important Documents and RFCs

Who is involved?

Can I mod on Fabric and Quilt?

I have more questions!

Quilt September Update

Clean Room RFC-33

Quilt Mappings

Quilt Standard Library (QSL)

Quilt Mod JSON

QuiltFlower

New Moderators

Modding with Quilt & Fabric

Can I mod with Quilt at the moment?

Are things still compatible with Fabric?

Round-off

Quilt's (VERY LATE) October Update

Quilt Mappings are now usable in Loom!

How to use Quilt Mapping (Gradle Plugin)

settings.gradle

build.gradle

New Moderators

Quilt enters Beta

Instability

Missing Features

Why we’re releasing now

Stay in the Know

Get Involved

Conclusion

Introducing BlanketCon!

Announcing the Quilt Forum

Where do I sign up?

Why do we need a forum?

Openness

Control

What will happen to Discord?

October: Month of the 'toberfests

But what are ‘toberfests?

How do I start?

Adding Cloudflare Web Analytics to quiltmc.org

Contents:

Analytics and Privacy

What Data Is Collected

How We Could Use the Data

Why Cloudflare?

Five vulnerabilities found in mrpack installer implementations

Quilted Fabric API: A call for contributors

Do I need to join a team?

I don’t feel like I know enough to contribute…

What can I do to help?

Quilt Mappings needs you!

What’s holding the team back?

Why even bother?

How can I help?

Evil Modding Project Adds Telemetry

Why are we doing this?

How are we doing this?

Will this steal my data, the family cat, and possibly my wife as well?

I don’t like that, how can I say no?

Quiltflower is now Vineflower

Why did this happen?

Quilt Loader Telemetry Explained

How the telemetry works

Why are we adding telemetry?

But Why Couldn’t You Just…

How to disable the telemetry

Quilt's (EXTREMELY LATE) November Update

Quilt Standard Libraries

Quilt Loader

Quilt Mappings

Quilted Fabric API

Chasm: Collision Handling ASM

Quilt Kotlin Libraries

Cozy

Miscellaneous Updates

Quilt Development Update: November 2023

Loader

Quilt Standard Libraries