Marita Pre-Beta

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.

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.