It's not every day you hear about someone rewriting tens of thousands of lines of code. Especially when that code is already working. But one developer decided to take on a huge project: moving a game from two established languages, D and C++, to a brand new one called Jai.

This wasn't a small hobby project. We're talking about a game with around 58,000 lines of code. That's a serious amount of work, built up over time. The decision to switch languages had to be a big one, with good reasons behind it.

Why Switch

Languages at All?

Moving code is hard. You have to make sure everything still works. You need to fix bugs that appear in the new language. So, why would anyone choose to do this? Usually, it's because the new language offers something better. Maybe it's faster, easier to use, or has features that make development smoother.

In this case, the developer was looking at Jai. This language is designed by Jonathan Blow, known for games like Braid and The Witness. Jai aims to fix many common problems developers face. It focuses on making things simpler and more efficient for game creation. The goal is to avoid the usual headaches that come with complex game projects.

The Challenge: 58,000

Lines of Code

Imagine looking at a giant wall of text. Now imagine that text is your game's code, and you have to rebuild it. That's the task this developer faced. Porting 58,000 lines means translating every single command, every function, every data structure. It's like translating a whole book into a different language, word for word, while making sure the story still makes sense.

This project involved two main languages: D and C++. C++ is a very common language for game development, known for its power but also its complexity. D is another language that offers some modern features while trying to keep C++'s performance. Switching from both to Jai meant a complete change in how the code would be written.

Getting Started with Jai

Jai is still a relatively new language. This means there aren't as many examples or tools available compared to older languages. The developer had to learn Jai deeply while also applying it to a large, existing project. It's like learning to build a house with a new type of hammer you've never used before.

One of the first steps in such a big port is to understand the original code well. You need to know what each part does. Then, you can start translating it piece by piece. This requires careful planning and a lot of patience.

The Porting Process: Step by Step

The developer broke down the massive task into smaller, manageable parts. They didn't try to rewrite everything at once. Instead, they focused on specific systems or features of the game.

This approach is smart. It allows the developer to test frequently. They could make sure that the Jai version of a feature worked correctly before moving on. This prevents small problems from becoming huge issues later.

Handling Different Codebases

The original project used both D and C++. This adds another layer of difficulty. The developer had to understand how these two languages interacted within the game. Then, they had to figure out how to represent that interaction in Jai. It's like having two different instruction manuals and needing to combine them into one new manual.

This often means making choices about which parts of the original logic are most important. Some things might be simplified. Others might need to be completely rethought to fit Jai's way of doing things.

Key Learnings from the Switch

As the porting continued, the developer shared what they were learning. These insights are valuable for anyone thinking about using Jai or undertaking a similar large-scale code migration.

One major point was how Jai handles data. The language has specific ways of organizing information that can be very efficient for games. Understanding these core concepts was crucial for making the new code perform well.

Another lesson involved error handling. Jai has different ways of dealing with mistakes in the code compared to D or C++. Learning these new methods and applying them correctly was a significant part of the process.

"The goal is to make the language get out of your way as much as possible."

• A key idea behind Jai's design.

Why Jai Might Be Worth It

So, after all that work, was it worth it? The developer seemed to think so. Jai promises to make game development faster and less frustrating in the long run. It aims to give developers more control without the steep learning curve of some other powerful languages.

By moving to Jai, the developer could potentially:

• Write code more quickly.

• Reduce the number of bugs.

• Make the game run more efficiently.

• Have a simpler codebase to manage in the future.

This kind of project shows the dedication of game developers. They are always looking for better tools and methods to bring their creative visions to life. The switch from 58,000 lines of D and C++ to Jai is a bold move in the world of game programming. It’s a story about pushing boundaries and seeking improvement, even when the path is incredibly difficult.

This massive porting effort is more than just a technical feat. It's a look at the future of game development tools. It shows that even with established code, there's always room to innovate and find better ways to build the games we love.