The Move to Python 3 Begins!

Capsuleers, 

EVE continues to evolve, as a part of the EVE Forever initiative, and it is time to cast the spotlight on the code itself! 

Underneath every gate jump, market order, and fleet fight in EVE Online, there is a very large amount of Python. It has run New Eden for more than two decades and now begins its transition to Python 3. For you, that means better tools to fix bugs sooner, room for new features, and a faster EVE over time. 

The definition of success for this migration is simple: it should be completely unnoticeable, aside from the occasional moment when something runs more smoothly. 

Many of you have already tested our first steps on Singularity, and those changes were deployed today. This is only the beginning of a long road ahead.

EVE launched in 2003, built on Stackless Python, a version of Python whose lightweight "tasklets" let a single server node juggle thousands of pilots at once. Fenris Creations did not just adopt Stackless; it became one of its most significant contributors.  

Some of you may remember upgrading to Stackless Python 2.5 in 2007, then to Stackless Python 2.7 in 2010. That was the last time EVE changed its Python version. Python 2.7 reached official end of life back in 2020, the rest of the software world moved on, and a whole generation of capsuleers has been born, gone to school, and started flying frigates while EVE stayed on the same language version. It was reliable enough that a large, potentially risky migration never justified itself, until now. 

Sixteen years on the same version says a lot about how well it worked. The Carbon engine helped massively, but it, too, has moved forward now!

The short version: staying on Python 2 increasingly holds EVE back, and moving to Python 3 means a healthier, better-supported game for you. 

One reason is performance. Recent Python 3 releases have delivered some of the largest speedups in the history of this language. Over time, that opens the door to a faster EVE, though it is too early to say exactly what that will mean. 

Another reason is the ecosystem. Modern libraries, debuggers, and profilers are all built for Python 3. Every year we remain on Python 2, more of them slip out of reach, and the more we must maintain ourselves instead of improving the game. Better tools mean we can find and fix problems faster. 

Python 3 simplifies many of the language's core building blocks.  

Text is handled through a single, consistent string type, making localization more reliable. Integers no longer have arbitrary size limits, growing automatically when needed. Even Python's class system has been unified, removing legacy behavior and making object-oriented code more consistent. 

Every character, every skill point, every asset in every hangar, every ISK in every wallet was written in Python 2 code, and all of it must read back under Python 3 exactly as it was. 

The path ahead is hard, we must update a massive amount of code while EVE keeps running for you, but we know the destination is reachable, because EVE Frontier already runs our Carbon engine on modern Python 3, and it works. 

The Frontier migration covered twelve minor versions of Python in one go, sixteen years of language evolution in a single project. Tranquility has twenty-three years of accumulated code, and, more importantly, twenty-three years of real player data, the history of capsuleers. And it must keep breathing 23.75 hours out of every 24. 

The EVE codebase consists of 2.4 million lines of Python. A lot of it predates even Python 2.7, written to standards from the 2.3 and 2.5 era that Python 3 refuses to parse at all.  

So how do you migrate 2.4 million lines of code? 

Very carefully, and in multiple stages. 

Some of these stages will use tools developed by the Python community (e.g., Python Futurize), while others will focus more on EVE’s unique features. 

When we hit key milestones, we will request your help by getting involved in playtests on Singularity, as you did in July, where we can observe how parts of the updated system behave under conditions closer to the Tranquility server. 

The first stage, where we are now, makes the code Python 3-ready while it still runs on Python 2.7.  

We use a tool called Python-Future, built on the same code-rewriting machinery (2to3) that Python itself shipped to help exactly this kind of migration. It applies automated "fixers", each of which rewrites one obsolete pattern, into a modern form that both Python 2.7 and Python 3 accept.  

Once all the code works under both versions, the genuinely hard work begins: the code that runs on both, but behaves differently. 

How do you even know how far you are from Python 3?  

We measure it. Every one of our ~20K Python files is compiled under a real Python 2.7 interpreter and a real Python 3 interpreter, because the compiler is the ground truth for whether code parses. 

The first scan was a pleasant surprise: 95.9% of files already compiled under both versions. The blocking lines, the ones using syntax rejected by Python 3, numbered about 3,300 out of 2.4 million.  

The mountain turned out to be a large and very measurable hill: 

•  ~ 1,500 old-style print statements, 

•  ~ 800 "long" number literals like 123L,  

• ~ 600 exception clauses in a syntax deprecated before EVE existed,  

• 50 uses of <>, a way of writing "not equal" so old that many working Python developers have never seen it. 

Parsing is the easy part.  

The same scan counts roughly 20,000 lines of code that compile fine under both versions but behave differently in Python 3. The classic example is division: in Python 2, 1 / 2 is 0; while in Python 3 it is 0.5.  

In EVE where those numbers might be damage, ISK, or coordinates, each of those lines needs a human decision rather than a mechanical fix. That work is part of Stage 2, which is why Stage 1 comes first: clear the mechanical debris so human attention goes only where humans are needed. 

In the short term, nothing, and that is by design. Stage 1 changes are meant to be invisible. In the long term, this is some of the most valuable groundwork we can lay for EVE's future: a faster interpreter to power fleet fights and market hubs, modern tooling that helps us find and fix bugs sooner, and a codebase new developers can work on more productively, which means features reach you faster. It is infrastructure for the next twenty years of EVE Online.

Noticing nothing at all is the goal, and you are the ones helping us reach it. 

At the end of July, you tested the first set of changes on Singularity. Thank you to everyone who took part. 

We are now deploying these changes to Tranquility. This is where we rely on you: keep doing what you always do, and if anything feels off, please let us know by filing a bug report.  

In addition, we are preparing the agent mission backend for Python 3, but you should not notice a thing. 

This is just the first step of many. Clearing the mechanical debris was the easy part. The real work, the code that must be read line by line, is still ahead of us, and that is where we will need you most. 

Keep an eye on our channels for future tests. If you have ever wanted to tell your corpmates you helped move EVE to Python 3, this is your chance! 

Fly safe, on whatever version of Python you find yourself.