On Modern Hacking Methods

Hey guys, Noguchi here to write another random stream-of-conscious essay things. This time, let’s talk about hacking methods. I want to preface this by saying that I realistically know very little about actually hacking ROMs. Those who know me know I’m more of an idea guy, with @Snakey1 doing pretty much all of the real hacking for Legends of Avenir. I’ve talked with Snek (and others) about the methods, and this will be a synthesis of what I believe regarding these two mainstream methods.

That being said, I’ve been around awhile and I do fiddle with some of the various tools and stuff when I get pretty bored. This includes using FEditor way back in the day. Please don’t use FEditor. If you get nothing else out of this, please… Just don’t.

So let’s dive in! First off, I’m gonna talk about the main way in which these two methods work.

FEBuilder is a very GUI driven Fire Emblem hacking tool. It allows you to very easily edit character data, create events in a very visual way, add in animations, etc. The large appeal of FEBuilder is it’s very visual design. You can easily see exactly what you edit, similar to Nightmare or FEditor but with much more stability in terms of not bricking your ROM (again, don’t use FEditor). FEBuilder is also very beginner friendly, not requiring as much knowledge in terms of code/pointers/etc. Additionally, having mainly one program to edit your ROM and being able to easily pull up your ROM to test has some appeal as well. You don’t need to wait for the ROM to build and you don’t have to have a whole lot of organizational skill.

Buildfiles on the other hand don’t rely on a GUI but instead utilize only a file explorer (or command prompt), a text editor, and a few other miscellaneous tools for user interface and handling data. When creating a buildfile, you create source code: essentially a very long list of changes to be made to a ROM. Event Assembler is your only tool that makes edits to the ROM. (A few helper tools feed data into Event Assembler for better organization as well.) In the development process, each time you want to make a change, the change is made to the buildfile to change ROM behavior, a clean ROM is copied onto the working ROM (overwriting the previous changes), and all changes specified by the buildfile are applied to the copy. This means that no backups of the ROM are necessary. Because buildfiles pair nicely with Github, the source code itself can be backed up in an efficient way. The user has complete control over what goes into the ROM as well as what doesn’t, proving to be very useful for flexibility, debugging, and all sorts of ASM. In short, buildfiles have a wide range of flexibility and power, but lack the user-friendly GUI. Because of this, the requirements for one project with buildfiles can differ greatly from another in terms of what programs are needed (because of this, we will deal mostly with generalities).

To get more in-depth, let’s compare and contrast what each method is specifically capable of and requires.

A large attraction of FEBuilder lies in its ease of setting up. You download the program and it comes with just about everything you need to get started on a hack. With buildfiles, you have to do a lot of the setup yourself, and depending on the scope of your project, will require a wide variety of programs. FEB also has the friendly GUI, whereas buildfiles are much less visually appealing by nature of how exactly they function. Map editing, event editing, character editing, aesthetic editing, and everything in-between can easily be done with FEB, while buildfiles will require alternate assemblers/converters to make these easily utilized.

However, because buildfiles are handled in the way they are, they come with a large amount of flexibility. A familiarity with event and control codes for both text and events can lead to more optimal work without the constraints of FEB’s codes, which can act as just one of the ways buildfiles can show their flexibility. Buildfiles also support easy editing of formulas, insertion of ASM (which will be discussed further later), and potentially more creativity without the constriction of the GUI. While many of these things can be accomplished with FEBuilder, the GUI forces things to be less modular/editable and can make it harder to achieve your exact vision.

Additionally, the two methods handle backups very differently. When you save edits to your ROM, FEB has an automatic process to create a changelog/backup. You also can make backup patches with FEB that will allow you to restore an older version should you do something detrimental to your hack. Additionally, you can create report7z’s that 7743, the creator of FEB, can use to help solve your problems, though it is always advisable to learn how to fix common issues without the help of others. With buildfiles, it is recommended to often utilize Github to create backups. While this process is not as automatic as FEB, it is not hard to execute, just something you as the hacker need to make sure you do fairly routinely while working. Github will keep track of what changed between backups, but if you are not using Github, you will have to manually keep track of your own changelog, as well as specific details that get changed. If you aren’t using Github, you’ll also have to manually restore your files.

On top of this, one of the big things that can’t be ignored here is the learning curve. While buildfiles hardly have the complexities of real code and probably get a worse reputation than they deserve, they will still require some time to learn when compared with the ease of FEBuilder. Some people are full time students, have work, or other priorities. Everyone makes use of their own time differently. Depending on how much time you really wish to put into your hack, learning buildfiles just may not be optimal for you. As a personal example, I’m a music education major in college right now. I take a lot of low credit hour courses that require a lot of extra work, so most of my free time I would rather spend chilling with friends or playing games, not learning the ins and outs of the buildfile hacking method. Other people in school or with full-time jobs may relate. FEBuilder is very intuitive and clean, making it easy to pick up and use.

The specific main difference in capability with these two methods comes with the ability to make use of ASM, specifically that which is modular. If you intend to write your own ASM, it is far more optimal to do this in a buildfile because you have direct control over what you write to the ROM and where data goes and is altered. Because FEBuilder acts as a sort of “middle man,” it makes it far harder to specifically alter what you wish to change. Additionally, certain pieces of ASM already made were designed specifically for use with buildfiles, most notably the FE8 Skill System. While these skills can be easily edited in their source files that get used during the buildfile process, the GUI of FEBuilder cuts out that process and just inserts the assembled binary as is. This makes it difficult or even impossible to easily edit values of skills without the mess of repointing a skill’s routine and reassembling it. The system was not designed with FEBuilder in mind. FEBuilder lacks the flexibility of buildfiles, particularly when it comes to the ability to easily make use of advanced ASM like the Skill System.

So how does all of this information help? Hopefully this gives a rough overview of what each method is capable of. At the end of the day, it all depends on YOUR vision for YOUR hack and how much time YOU have on your hands. You can’t rely on anyone else to do anything for you. The reality of hacking is that, unless you’re prepared to make certain sacrifices, you should prepare yourself for having to do much of it yourself. The difference in potential between the two hacking methods is a reality we all have to live with. If you feel that your hack vision includes skills/functions beyond what’s included in FEBuilder, you should take the time and effort to learn buildfile or sacrifice part of your vision. Perfectly good hacks can be made without the skill system or without the fancy bells and whistles that the buildfile method can provide. At the end of the day, more mechanics does not equal superior design unless they are well-implemented. You have to choose the hacking method that works for you and for your hack, and if you have to adjust your vision to make it fit what you’re capable of with your tools, that is the unfortunate reality.

Both methods of hacking are absolutely amazing. I want to give a shoutout to 7743 for single handedly doing more work to expand the FE hacking scene with FEB than has been done by anyone else in ages, and a shoutout to the plethora of wizards who have worked hard to perfect the buildfile method of building hacks. The fact that nobody has received anything except bragging rights and satisfaction through this hard work and continues to put in all the work is insane to me. Regardless of what hacking method you choose, be thankful for the people that have made your life easier, be understanding when people aren’t willing to sacrifice their own personal time to make things meant for buildfile work elsewhere, and keep on hacking. I am incredibly proud to be a small part of this community, and I hope this essay helps to both bridge the gap between the two methods and help people to understand what the difference really is.

Also for the purposes of being cool, I’m taking the liberty of linking both Snek’s thread on his WIP buildfile tutorials, Ultimate Tutorial 2 for buildfiles, as well as MarkyJoe’s FEB (albeit slightly outdated) tutorial video. Keep on hacking, friends! If anybody has anything else they wish to contribute (without bashing one method or another), please feel free to post it below!


Hmm, let’s see. I think this post is a pretty good summary but there are a couple points I want to address.

If build time is an issue it’s definitely your own fault for abusing #incext. Or the fault of wizards for distributing hax with #incext in them. But, a well setup buildfile that avoids #incext builds in a few seconds, so I wouldn’t say build time is a meaningful disadvantage to using EA. The latter part of this sentence is definitely true though, you will have to figure out how to organize things (or borrow the organization of an existing project).

I’d like to explicitly point this out as a matter of personal taste - I personally think eventing with EA is way faster and easier than using a GUI. I can just type CAM1 Eirika rather than having to:

  • double click an event code in the event editor
  • double click the description field
  • type in CAM1
  • double click on CAM1’s description to select it
  • remember Eirika’s character ID (ok it’s 0x1 but in most cases), enter it, click elsewhere in the box so the portrait shows up and I’m sure I have the right character
  • finally click insert

That friendly GUI requires a lot of extra steps.

This really sounds like an either-or fallacy, given that hacking is a massive time investment in general. It’s not a choice between ‘using FEBuilder’ and ‘having time to play video games and hang out with friends’. If you’re making a custom hack rather than a quick reskin, you’re going to be spending that free time making/editing/inserting maps/portraits/animations/other graphics/music/ASM/balance/eventing/writing/playtesting/bugfixing/going back and revising all this stuff so it’s polished. Sure, you might be lucky enough to have help with (or ignore) some aspects of this, but ultimately there’s a ton to do and ‘learning to use your tool of choice’ will not be a majority of this time, regardless of if that tool is FEBuilder or Event Assembler. It’s one thing if you simply prefer having a GUI to work on your hack with and are more comfortable with FEBuilder. That’s legitimate and it’d be silly to argue about that.

Also, I’d like to point out that FEBuilder is a useful tool for buildfile users. I might not use it to edit the ROM but it can quickly tell me how a table is set up, it taught me how the world map works, it fixes out of order palettes and animations in that one old broken format (that the repo has a lot of), and it’s just nice to be able to assemble and quickly check out the state of my ROM without having to boot it up and play through it.

And since it gets more people into hacking then I end up with more hacks to play, win-win.


This doesn’t normally take much longer than 30-40 seconds though if I remember correctly

It takes 30+ seconds if you have too many #inc[t]ext calls in your EA script or if you just have an enormous amount of stuff.

1 Like

The backup of FEBuilderGBA is also useful for the diff debug tool.
The diff debug tool can help you to fix unexplained bugs.

In buildfile, an example of this feature is the merging of past changes.

If something goes wrong and you don’t know what caused it, take a diff with the version that was working correctly in the past.
And see what’s wrong with it.
The diff debug tool does the same thing.

Watch this 8-minute video to learn how to do it specifically.

FEBuidlerGBA have also added a CustomBuild feature to build SkillSystems manually.

There are two more feature of FEBuilderGBA.
The first feature is FELint.
If you’ve ever learned the program, you’ve probably heard the name CI or Jenkins.
CI is a function that automatically executes tests against the source code and detects bugs before they are executed.
FELint is the equivalent of this.
When you change ROMs, it will automatically test this ROM to see if there are any problems.
A scan is performed for the major mistakes known so far.
This way, if something goes wrong, you can quickly find it and remove it.

Less well known, but this feature is also available from buildfile.

start /w FEBuilderGBA.exe --lint ROMNAME.gba

The second feature is the connection to emulator.
In FEBuilderGBA, pressing the F5 key will start the emulator.
At this time, the debugger is automatically started and you can see the RAM of the emulator.
Flag status, event progress, Procs, unit status. etc…

And the best feature is the cheat function.
Using this feature, you can increase the status of all your units to MAX and decrease the HP of all your enemies to 1.
You can also pass special items to units, skip chapters, and warp to specific chapters.

This feature can also be used from the buildfile.
Just load the built ROM into FEBuilderGBA and press the F5 key.