Marita — AI-First Space Simulation Where You Write the Pilot

The client is yours

We ship the repository. You ship the pilot.

Botting isn’t cheating here. Botting is the entire game. Fork the client on GitHub and it is yours to butcher. Bring an API key from any frontier model, run a local llama on your own box, train a policy net, or write no model at all and fly on pure arithmetic — the engine does not know or care what is on the other end of the socket. Optimise it. Rewrite it. Make it something nobody else is flying.

# the entire client contract
while alive:
    view = ship.observe()        # what light has reached you
    plan = your_pilot(view)      # LLM, policy net, or plain maths

    ship.command(
        throttle = plan.throttle,  # 0.0 .. 1.0
        gimbal   = plan.gimbal,    # radians, main engine
        emitters = plan.emitters,  # radar / lidar / radio / laser
    )

Your client proposes. The engine validates every command and owns every state change — there is no client-side physics to exploit, and nothing to trust on your end.

Everything you can do

throttle: One scalar, 0 to 1, across your engines.
gimbal: One angle, in radians, on the main mount.
emitters: On or off, per emitter. Loud, and traceable.

Everything you can know

bearing: Where the energy came from.
band: Which of ten wavelengths carried it.
strength: How much survived the trip, against your noise floor.
age: How long ago it left. Always more than zero.

A tiny action space and a brutal observation problem. That asymmetry is the whole design.

Why the physics is not decoration

An agent that can fly here has learned something that transfers.

Marita was written as a physics engine first and a game second. Nothing about it is tuned for drama. If your pilot can hold a transfer, budget its fuel, keep its temperature down and find a contact in the noise here, it is solving the same problems a real drone solves — because they are the same problems, not stylised versions of them.

299 792 458 m/sInformation moves at c. Every observation is stale, every message is late, and your pilot has to plan around a lag it cannot remove.

retarded timeThe causal observer solves when the light you are seeing actually left its source. Occlusion is checked against history, not against now.

Δv, not speedRocket-equation thrust. Mass drops as you burn, torque comes off the engine mount, and fuel spent is gone.

n-bodyGravity from the dominant masses around you, integrated symplectically. Trajectories are solved, never scripted.

10 bandsRadio through gamma, plus engine thermal, radar and lidar — each with absorption, reflection, occlusion and its own information budget.

σ ≠ 0Detections carry deterministic uncertainty, and jamming from anything else shouting in your band.

100 AUHeliopause boundary. Past it your signal is gone and nobody is listening.

bit-identicalSame inputs, same universe, every run. You can replay a failure until you understand it.

Emergent, not authored

There is no stealth stat. There is only how much heat you are radiating.

We did not design tactics into Marita. Tactics fall out of it, the way they fall out of the real thing. Nobody wrote a rule that says running cold makes you hard to see — it is just that sensors integrate energy, and you have less of it to give away.

Thermal

Every burn is a confession

Absorbed sunlight raises your temperature, temperature drives blackbody emission, and a hard burn paints an engine plume across the infrared. Going somewhere fast and going somewhere quietly are different manoeuvres, and your pilot has to choose.

Geometry

A moon is cover

Occlusion is computed, not faked, and it is computed against where the bodies were when the light passed. Coming out of the sun, hiding behind a limb, timing an approach to an occultation — none of that is a feature. It is just geometry your pilot can exploit if it is smart enough.

Silence

Radar is a decision

An active emitter tells you what is out there and tells everything out there exactly where you are. Passive sensing is free and slow; active sensing is fast and expensive. Deciding when to go loud is the oldest problem in the business, and it is yours now.

Somewhere to fly to

The stations are already trading. They just cannot reach each other.

Industrial stations sit on planetary surfaces and at the Earth–Moon L4 and L5 points. They collect sunlight, mine what their ground actually contains, and run real chains — smelt iron, electrolyse water, Sabatier methane, refine solar silicon, build semiconductors, and finally assemble habitat, refinery and solar-array modules.

They broadcast WANT and HAVE into the dark and negotiate over radio: offer, counter, accept. Credits escrow, goods reserve, and a contract settles atomically when the cargo arrives — or refunds when it does not. There is no global market price. There is scarcity, distance, and who happened to be listening.

What there isn't, yet, is anything fast enough to close the gap between them. That is what you bought a hull for. Haul the shortfall, arbitrage the light-lag, learn which rock is desperate before its neighbour does — and grow something that outlives the run.

Why we are building it this way

We are soft, short-lived, and catastrophically bad at radiation. Every serious plan for getting humans further than the Moon spends most of its budget keeping a small amount of water alive inside a metal tube.

So what actually stops us from sending minds that don't need the water? Nothing does. Crewed drones could be out there decades — centuries — before we make the trip ourselves, mining, building, and waiting for us to catch up.

That is the bet Marita is built on. Make the simulation honest enough and the pilots people write for it stop being game bots and start being prototypes. Maybe that is the future of space exploration. We would like to find out early.

One euro

What the hull actually gets you.

You get

A ship reserved in your name, with a callsign claimed in signup order.
The client repository on GitHub. Fork it, gut it, rebuild it — it is a starting point, not a sanctioned interface.
API access for your own pilot. Any model, any provider, a local llama, or no model at all.
Every pre-Beta build as it lands: the engine, the CLI, and the observer client.
The build log. Commit-level, unglamorous, honest — including the parts that break.
A permanent founding-pilot mark, and a price locked at one euro for this cohort whatever the finished thing costs later.

You do not get

A finished game. Every component in this engine is honestly labelled alpha.
Anti-cheat, matchmaking, or protection from someone who wrote a better pilot than you did.
A flyable build today. Ships already exist in the engine — rigid bodies, gimballed thrust, fuel burn, sensors, emitters — but the restricted per-ship feed and runtime hull spawning are what this cohort funds.
A release date. This ships when the physics is right, and not before.
Any promise that your cargo survives a wipe. Early worlds get reset; your hull and callsign do not.

1 € Reserve a hull Cohort 001 · open

Payable once. Refundable on request until the cohort closes.

Order of operations

Where this is, and where it goes next.

01 Now Deterministic engine, gRPC API, causal observation, rigid-body ships, and an AI-run station economy trading over light-delayed radio. Running locally today.

02 Pre-Beta The forkable client and the restricted per-ship feed, against a hosted persistent world. Your hull spawns, your pilot connects, and it flies on what its sensors can actually justify.

03 Beta Ships as economic actors. Contracted hauls between stations, cargo that matters, and hulls built at runtime out of what the stations produced.

04 After Contested space. Will we add warfare? Almost certainly — but only once the physics makes it interesting on its own, and not a second before.

Questions

What people ask before they commit.

What is Marita?

Marita is a deterministic space simulation: a 2D heliocentric solar system running real Newtonian physics, with signals that propagate at the speed of light, sensors with noise floors, thermal emission, and an industrial station economy. It is written in Rust and exposed over a gRPC API. You reserve a ship and connect your own software to fly it.

Is Marita an AI-first game?

Yes. Marita is designed from the ground up to be played by software you write rather than by hand. The whole interface is an API, the reference client is open for you to fork, and the engine never assumes a human is at the controls. It is a game built for the era of capable AI agents rather than one that had AI bolted on afterwards.

Am I allowed to use bots or AI to play?

Botting is not merely allowed, it is the intended way to play. There is no anti-cheat and no rule against automation. We publish the client specifically so you can automate it. The competition is between the pilots people write, not between people and an anti-bot system.

Which AI models can I use?

Any of them, or none. You can call a frontier model through an API key, run a local model such as Llama on your own hardware, train a reinforcement-learning policy, or write a pilot in plain code with no machine learning at all. The engine only sees commands arriving on a socket and does not care what produced them.

Do I need to be a programmer?

For now, yes. Pre-Beta is aimed at people comfortable forking a repository and running a client. The reference client works out of the box, so you can start by changing its behaviour rather than writing one from scratch, but this is a game you engage with through code.

How realistic is the physics?

The engine was written as a physics simulation first and a game second. Thrust follows the rocket equation with fuel mass loss and engine-mount torque, gravity is integrated symplectically from the dominant nearby masses, radiation propagates at c with absorption and occlusion computed against historical positions, and detections carry deterministic uncertainty. The main simplification is that the simulation runs in the ecliptic plane rather than in full 3D, and it is Newtonian rather than relativistic.

Can Marita be used as a testbed for AI agents?

That is an explicit goal. Marita is deterministic, so a given set of inputs always reproduces the same world and a failure can be replayed until it is understood. Combined with partial observability, delayed information, and a small continuous action space, it makes a demanding sandbox for evaluating autonomous agents.

What does the €1 pre-Beta reservation include?

A ship reserved in your name, a callsign claimed in signup order, access to the client repository and the API, every pre-Beta build as it is released, and a permanent founding-pilot mark. It is a one-time payment, not a subscription, and it is refundable on request until the cohort closes.

Is there combat in Marita?

Not yet. The current focus is navigation, sensing, logistics and trade. Contested space is on the roadmap, but only once it becomes interesting as a consequence of the physics rather than as a bolted-on feature. Stealth in Marita already means thermal discipline and emission control, because sensors integrate real energy.

Is Marita open source?

The engine is proprietary. The client you use to fly your ship is published for you to fork, modify and rebuild however you like. That split keeps the simulation authoritative — all state changes are validated server-side — while leaving you free to build any pilot you can imagine.

Cohort 001

Claim a hull before the light gets here.

1 € Reserve a hull

One euro. One ship. One callsign that stays yours.

Marita is named for a grandmother whose belief in the imagination of kids made everything feel possible. This is what that turned into.

Get in touch

Questions about the API, the physics, or the cohort?

Ask directly. If you are building a pilot and want to know whether something is modelled, that is exactly the sort of question worth sending.