This article is the first in a series of tech posts documenting some of the hacking work we’ve done on the engine. I’ve got a good pile of content to share here, so I hope you enjoy the ride!

Back when I joined Operation Bellflower, our team lead Kazoo was specifically recruiting for a hacker rather than a programmer. At first, I didn’t exactly understand why. I consider myself firmly in the second category but naively assumed that I could still apply most of the code wrangling knowledge I got from my years of making games on Roblox writing serious professional software. But it turns out that this is not just about writing code, it’s first and foremost a matter of breaking down piece by piece a whole engine – that is hacking.

So when I jumped in, I was pretty new to this hacking thing. I thought I had a good grasp on how computers work, but the BGI/Ethornell Engine would keep proving me wrong. This is why plunging into the innards of this anime PowerPoint program ended up being such a learning experience. A painful one at times, but nonetheless a wonderful adventure, and one I would heartily recommend.

The goal of this series of articles is to share this journey with you, whether you’re a seasoned code person or just a curious passerby. For those in the second category I will do my best not to dive too deep into the technical intricacies, at least not right away (I promise, I won’t show a single line of code until the second article). We’ll start off slow with a quick overview of exactly what we’ll be dealing with as well as a list of helpful resources.

So what is an Ethornell?

If the Buriko logo looks like something straight out of the latest millennia, that’s because it might very well be

Senmomo is built upon a visual novel development framework called the Ethornell Engine, or Buriko General Interpreter. You’ll have a hard time finding more high-level information than this, because you have to understand that we’re dealing with a niche engine for an already niche subgenre of video games. If you really dig down you might find Buriko’s official website, which, asides from looking like it was created when I was barely even born, seems to hold less information than the BGI page on French Wikipedia (yes, oddly enough that one is more complete than even the Japanese page). 

Do you understand when I say that this is going to be an adventure? We’re really gonna be exploring dark, unknown territories. So before you ask perfectly reasonable questions like why does it have two names? or what even is a Buriko? I’m sorry to say that your guess is as good as mine. But don’t let all of that discourage you, as there are plenty of community resources online that we’ll get to in a bit.

There are a couple of big names in the VN industry that adopted BGI as their primary engine. Parroting the above Wikipedia page (finally, me being French is good for something), some of these names include Sprite, Makura, Lump of Sugar, Overdrive, KeroQ, and of course Senmomo’s developer August, otherwise we wouldn’t be here.

Ethornells, how do they work?

Let’s talk briefly about programming languages, because one thing that’s important to mention before diving in is which underlying technology the engine uses. Reasonable VN engines are the ones that use scripting languages, like Ren’py with Python or Kirikiri with its pseudo-Javascript. Unfortunately for us, BGI is not a reasonable VN engine. It uses instead a compiled language (most likely, C or C++). The important distinction here is that while code written in a scripting language can perfectly be run as-is, compiled language programs cannot. They are instead meant to be converted (or compiled) to another language that the computer can understand, at the detriment of human readability.

This compiled code is what’s being shipped to us, the users, and here lies the biggest challenge of working with BGI: we don’t have access to the original source code as it was written by the developers. What we get instead is what’s called assembly code. Assembly is a programming language that’s so efficient for your CPU to understand that it becomes completely impossible to decipher for us people. Okay, maybe not impossible, but all the information that make a program readable, like code comments or variable names, is completely lost. This might sound scary, but you will be surprised by everything we’ll be able to accomplish without even looking at this assembly code. We’ll go into more details in the next articles, but for now let’s finish up with a list of useful community resources.

A couple of cool community creations

Despite the complete lack of official information on how to manipulate the BGI engine, we’re far from the first to attempt so. Many kind souls have uploaded their tools and knowledge as public open-source projects, and it’s safe to say that without those our little translation project would have been dead before it even started. So let’s take a look at some of the ones we found most useful. If you find yourself hungry to know more about the engine, I highly recommend snooping through these repositories and their source code.


If you’ve ever tried extracting data from any visual novel, chances are you’ve already run into this one. That’s because this is a massive group effort from many contributors in the community to create a program capable of breaking down pretty much any visual novel.

Full-length VNs often include thousands of assets, and that’s why developers have to package them into archives, sometimes in some pretty exotic formats. Game Archived Resources bro(wser) solves the issue thanks to this nifty archive browser, where you can just click through archive files as if they were regular folders and see what’s inside.

You also get tools for mass-exporting contents of entire archives, if your hard drive can handle it. Doing it the other way, though, is slightly more complicated. GARbro does offer some tools for re-packing archives, but they are less comprehensive than the extracting tools. There isn’t a repacking format that works for our BGI script files, for instance.

The next article will start off with a quick tutorial on how to use this tool for extracting our game’s data, so stay tuned for more GARbro goodness!

When it comes to extracting data from VNs, this program’s a real bro

ArcusMaximus’s VNTranslationTools

This one features two components. The first is VNTextPatch, which is without exaggeration the cornerstone of our translation workflow: it’s what we use to inject our translations back into the game files. You give it a scenario script (those are the files that contain the original Japanese text) and it spits out the handy spreadsheet pictured below. Once our dear translators, editors and TLCers fill in their respective columns, all we have to do is use the tool again to regenerate the corresponding scenario that looks exactly like the original, but with our translation instead of the original text. Filling out these spreadsheets really is the bulk of the project’s workload. It might look like I’m trying to steal the spotlight for the hacking work with these articles but don’t be fooled, Lonesome and Kazoo are the real heroes here. They are the one who took upon the gargantuan task of filling out tens of thousands of these lines across no less than 126 of these spreadsheets. Should you be interested in following their progress, we’ve put up a tracker here.

VNTextPatch was not formerly released, so it requires you to download Visual Studio and build the executable yourself if you want to try it out. It doesn’t have a fancy UI like GARbro, so you’ll have to spin it up through a terminal console like the true hacker you are (check out the repo’s readme for the exact syntax). This might sound like a lot of trouble, but you’ll be rewarded with the best translation patching tool currently on the market.

Translating a VN is easy! Just fill out the blanks… 76259 times.

You will also find another tool called VNTextProxy. It’s a swiss army knife of small utilities that modify some of the engine’s behaviors. For example it can affect the way the engine displays text on the screen, to perform things like letter spacing adjustments (this can fix problems that arise from the fact that unlike Japanese ones, English letters have different widths), special character support, and basic text formatting. How it works is that it generates a DLL file that the engine eats up, resulting in it happily running not only our custom text display functions, but also any custom behavior we want to add. This project has been a huge source of inspiration for some of the biggest hacking tasks, so we’ll make sure to dissect it properly in its own article.

ArcusMaximus’s EthornellTools

Another one from ArcusMaximus, because that’s how awesome they are. Unlike the aforementioned VNTextTools, this project focuses on the Ethornell engine in particular. You will find a program capable of re-packing our translated images back into something that the engine can read, as well as a disassembler for the game’s scripts. The latter will be especially helpful to us when we get to look at that assembly code. I know I said earlier that we can get away without diving too much into the assembly, but it will still be helpful to do so to get a better understanding of what’s going on, and ArcusMaximus’s disassembler will make the job slightly less impossible. 

Bonus: OpenBGI

Not exactly a tool per se, but I felt the obligation to include this one in the list because you have to recognize the dedication of the absolute madlads who took it upon themselves to fully re-implement the whole engine from scratch, and publish it as an open-source project. Remember how I mentioned before that the game code comes in assembly language? What these guys are basically doing is they’re building a program that can read that game code and run a given visual novel just as if it was played normally by original BGI engine. They’re still quite a ways from having it work, but they’ve done some very decent progress so far. This can be an extremely valuable resource if you want to know exactly what BGI’s code does. You can just look through their implementation and see how their bootleg BGI interprets each of the assembly instructions in script files.

This has been a pretty sizeable introduction post, but be assured that we’ll get into the nitty gritty of things right away in the next post. The two or three following articles will focus on how to apply a translation to the game’s original script. I promise it’ll get even crazier when we get to DLL proxies and API hooks, but I don’t want to spoil too much. So I hope you’ll like the journey through the BGI/Ethornell engine as much as I suffered enjoyed it. Have fun and see you next time!

Any question, comment, concern, or just want to say hi? Do hit me up on Reddit or Discord at Perturbed_pangolin#3792, or shoot me an email.

Leave a Reply

Your email address will not be published.

You may use these HTML tags and attributes:

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>