Hi. I’m Batuhan — most of the people I work with call me Babbus. We’ve been building something for a long time and this is the first dispatch we’re sending about it.
Why we’re doing this
I want to play this game.
That’s the honest start. For years I went looking for it — physics-driven flight combat in third person, co-op, open-world, with the build-depth of a mech game and the moment-to-moment of a flight sim — and I couldn’t find it. A handful of games came close in one direction, but none of them did all of it at once. So we started building it ourselves at STRUX Games.
The game is called A.R.C.X Fighters. You pilot a modular combat craft in a war-torn sci-fi universe. Every engine you bolt on, every weapon, every armour plate changes how the ship actually moves and fights — not on a spec sheet, but in the air, in the seconds that decide who goes home. You start as an Imperial Core soldier on Kharos-7. The missions escalate. Something breaks. That’s your story, and you decide what comes after it.
What shaped it
ARCX stands on the shoulders of games we love. Ace Online is the direct ancestor — vertical dogfighting, build-driven customisation, stat-driven flight. I grew up on it, and nothing has really replaced it. ARCX is carrying that DNA forward onto a new generation of hardware. From Armored Core 6 we took the obsession with the assembly screen — the feeling of building a machine and having it land in the field as that specific machine. From Helldivers 2 we took the hangar-to-mission loop and the functional military tone of going out on a run and coming back with stories. From Ace Combat 7 we took in-mission narrative told through the radio while you’re flying, not in cutscenes between missions. From Guild Wars 2 we took open-world events that don’t wait for you to be ready. From Monster Hunter World we took the hunt-reward-craft loop — gear is earned in the field, and hard content opens harder content. We’ll go deeper on each of these in future dispatches.
Where we are right now
This is pre-alpha and I’m going to keep every dispatch honest about state. Polishing the truth is how indie dev audiences get lost.
The flight is real. The full physics-driven flight model is in engine and running. Mass, drag, lift, thrust, stall — the whole contract is simulated. When you pull into a hard turn in ARCX the ship has to earn it. If you dumped half your boost on a dodge two seconds ago the physics remember it. We didn’t approximate any of that. We built it from the metal up, because in this game, flight isn’t a feature — it’s the game.
Here it is in the air. Early capture, no combat systems wired yet — just the ship, the physics, and a pilot pushing it around.
The nav mesh thinks in three dimensions. We wrote a 3D octree A* pathfinder from scratch. When the enemy AI hooks into it, ships are going to route through space the way a real pilot would — around terrain, around cover, around each other. A lot of flight games fake AI in 2D with a Y-value taped on. Not this one.
Silikron is generating. The planet you’ll be flying on is being built in real time by a GPU-driven procedural generator called StruxTerrain. Real geology — plates, ridges, coastlines, ocean basins. Not a landscape painted on a sphere. An actual world the engine is drawing from first principles.
Ships exist. The first Razor-class prototypes are in the hangar. Nova is the first manufacturer on file. More are on the way.
A quick word on what “porting” means
This is the part I want to be careful about, because I’ve watched indie devs get mauled for saying “we’re moving to ECS” and having the community hear “they threw out everything and started over.”
We did not throw anything out.
Games are built on code frameworks. The one we started ARCX on is called OOP — object-oriented programming. It’s the normal, battle-tested way most games are built, and it’s what we used for the first working prototype of the whole loop: flight, items, ships, missions, all of it. OOP is reliable and fast to iterate in.
Here’s the prototype loop in motion — flight, briefing, mission, engagement, return. Same build that’s now being carried across to the new foundation.
The catch with OOP is scale. It starts to struggle when you want thousands of things on screen at once — squadrons of enemies, clouds of projectiles, whole mission chains thinking simultaneously while planets generate underneath them. Your framerate pays for every single thing the CPU has to track.
So we’re moving the game onto a second architecture called ECS — entity-component-system. ECS is a different way of organising the game’s data so a CPU can chew through massive workloads without choking. That’s the whole reason it exists.
ECS is a general pattern, not Unity-specific. The way we’re getting it into ARCX is through Unity’s DOTS — the Data-Oriented Technology Stack. DOTS is a bundle of three tools that work together: Entities (Unity’s ECS implementation), the Jobs System (which spreads work across every CPU core in parallel), and the Burst Compiler (which turns our C# into optimised native machine code at build time). ECS is the architecture. DOTS is how Unity lets us actually ship it.
We needed both frameworks in this project. OOP to prove the design fast. DOTS to carry it to the size we’re building toward. Here’s what that means for ARCX in concrete terms.
Flight is the one thing we rewrote. We didn’t port the flight model. We rebuilt it from scratch on DOTS, because flight in ARCX isn’t a feature — it’s the game, and we wanted the physics running at real load, at real scale, with nothing cut. It was worth every hour.
Items and equipment are being ported, not rebuilt. The whole build-your-loadout backbone — the part list, the slot rules, the hardpoint logic, the way gear attaches to a ship and changes how it flies — already exists, tested and working in the prototype. We’re carrying it across to the DOTS layer, not starting over. When it lands on the production build, you’ll be able to shop, craft, and actually assemble your machine.
Missions are being ported, not rebuilt. The mission framework — briefing, objectives, rewards, the full loop from contract to payout — is up and proven in the prototype. Same story. Port, not restart.
That’s the real picture. The things players will feel the most — the flight, the build, the mission loop — already exist. We’re not starting over. We’re moving up.
What’s still ahead. Combat feel is next on the line — weapons and damage are designed, wiring them into the DOTS layer is the job. Enemy AI rides in after that, with the pathfinder already waiting for it. Co-op networking comes behind the vertical slice. It’s not a short list and I’m not going to pretend it is.
What we want from you
Join the Discord. Watch the work happen in real time. Every dispatch from here is going to be about a specific thing — a system shipping, a ship rolling off the prototype line, a world taking shape, a problem we had to solve.
If you want to see a game like this exist, stick around. We’re building it.
Early prototype footage — click to open
Fair warning. This is early. Debug gizmos everywhere, physics fighting itself, the whole thing held together with duct tape and optimism. The flight model has come a long way since this was captured — none of this jank survived. I’m putting it here because I think there’s something honest about showing where a thing started, not just where it is now. Don’t judge the game by this. Judge it by the dispatches that come after.
— Batuhan “Babbus” Yıldız · STRUX Games