STATUS: PROPOSAL · NO CODE WRITTEN YET · MILESTONE 0 IS ONE PC ANSWERING ONE QUESTION

Decentralized AI · No data center · No token

Your graphics card works for the world while you sleep.

The most powerful computer in your house spends every night doing nothing. Meridian Moonlight turns idle PCs into a free AI network — real models, real science, on hardware you already own and electricity you're already paying for. Phones extend the reach. The PCs do the work.

Follow-the-moon · modelled global device availability Simulated 24-hour cycle
Time (UTC)00:00
Fleet contributing
Never below
Night-side regions

Modelled, not measured — publishing the real curve from real nodes is Milestone 2.

What we're building

Three pieces. The first one is a desktop app.

None of it exists yet. This is the build order and the reason for it — and the only thing that matters right now is the bottom row.

Three pieces. Piece one, the primary node: a desktop client running a whole model on the graphics card you already own, chosen first because it has no app store review, no background limits, and no thermal ceiling, and because it unlocks models up to 32B and 85 percent of research capacity. Piece two: a coordinator and dashboard that routes by capability, hides canary tasks in real work, and re-checks answers at random, but cannot send you code, override your idle rules, or read what you process. Piece three, the extension: a phone client adding reach and time-zone coverage. Participants see one switch, one indicator, and one log. The first milestone is one PC answering one question, measured speed and watts and heat published even if bad, and a sixty-second video of it working.
The build order, and why the desktop client comes first

What it can do

Two products from the same idle machine.

Two products. For people: free AI that is actually good, with no account, rate limit, retention, or price. The model ladder runs from a 3B model on a phone, to 8B on most PCs, 14B on a 12GB card, and 32B on a 24GB card which is the tier people pay for. 331,000 enthusiast PCs would serve 100,000 people at once on the 32B tier, which is 1.1 percent of the machines already able to run it. For research: a research instrument owned by nobody. Folding@home at its peak delivered 2.4 exaFLOPS; 1.3 million gaming PCs match it; every capable PC delivers 538 exaFLOPS, or 224 times. Phones reach the same parity at 31 million devices. What it cannot do, stated up front: never out-compute a data centre in raw operations, never train a frontier model.
What the network is for — and what it will never do

More AI than
its members
can use

It serves the people in it — from the first thousand machines.

Capacity and membership grow together, so every participant's share is about 274,000 words of AI output per day — roughly nine times what even a heavy user consumes, and five times that at the quietest hour of the global day.

That ratio is identical at a thousand devices and at a billion. There is no critical mass to reach, no chicken-and-egg problem that needs a token to solve, and no point at which this becomes useful — it starts useful.

The ~89% surplus is a research instrument.


The primary path

PCs do the work. Phones extend the reach.

A gaming graphics card does the scientific work of about 32 phones, and it's the only hardware that can host a model big enough to compete with what people currently pay for. There are far fewer PCs, and people switch them off at night rather than plugging them in — and they still supply 85% of the network's science capacity.

So the desktop client is what we build first, and it's what the numbers on this page are about. The phone client follows, and it's where the mission scales — a billion devices already plugged in every night, reaching people who don't own a PC at all.

Primary · the engine

PCs and Macs

Machines in scope
920 million; 250M with a real graphics card
Biggest model it can host
32B on a 24GB card — the tier people pay for
Sustained science throughput
9,600 GFLOPS on a discrete GPU
Available at any moment
19.6% average — lower, because PCs get switched off
Folding@home parity
~1.3 million gaming PCs
Nothing in the way
No app store review, no background limits, no thermal ceiling

Extension · the reach

Phones

Machines in scope
1.2 billion with 8GB+ RAM
Biggest model it can host
3B — useful, not impressive
Sustained speed
12 words/sec
Available at any moment
25.7% average, 14.1% floor — higher, because phones get plugged in
Folding@home parity
~31 million devices — 24× more machines for the same science
What it adds
Reach, time-zone coverage, and free AI for people who don't own a PC

One detail that cuts against our own framing, because it should be said: a CPU-only desktop (0.20 TFLOPS) is worse for science than a phone (0.30). The advantage is entirely the graphics card — an office PC without one adds a machine and almost no capability. "PCs first" really means "graphics cards first".

Move the PC slider. Watch free AI arrive.

How many people could be talking to a capable model at once — and at what quality. The science comes out of what's left over.

Free conversations at once concurrent, at reading speed
Of those, at 32B quality the tier people pay for
People served per day at heavy daily use each
Science, from the surplus × Folding@home at its peak

Who you recruit matters more than how many. The slider enrols typical PCs, and only about 3.3% of those have a card big enough for the 32B model. Recruiting enthusiasts directly is roughly 30× more efficient for the flagship tier: 331,000 machines with 24GB cards would serve 100,000 conversations at 32B — the same as enrolling about 10 million PCs at random.

Assumes 26 words/sec sustained per PC and 12.3 per phone, 19.6% and 25.7% mean availability, 15 words/sec per active conversation, and 30,000 words a day for a heavy user. 3.3% of PCs can host a 32B model fast enough to hold a conversation. Every constant is named in compute_model.py and model_ladder.py.


How it works

Whole models on each machine. Night does the scheduling.

Right work, right machine. Three classes of job arrive: a quick question needing speed, a hard question needing a big model, and overnight science needing floating-point. The coordinator matches each against three things — capability, meaning what will actually fit and run fast enough; trust, meaning whether the machine may answer alone or must be corroborated; and availability, meaning idle, powered, and on the night side. The fleet is not uniform: a PC with a 24GB card hosts 32B for hard questions and heavy science, a PC with an 8 to 12GB card hosts 8 to 14B and real FP32 work, a charging phone hosts 3B for quick questions, and a CPU-only box with 64GB RAM can hold a large model but is batch-only. Answers are checked by hidden known-answer tasks, silent re-checks against a trusted reference, and redundancy scaled to stakes. A job is a prompt plus a task-type ID, never a script, binary, or container.
One prompt, three machines, one verified answer
On your device

A complete model, not a fragment

Every machine runs an entire model locally — up to 32B on a 24GB graphics card. Nothing is split across the internet, so there's no lag from shuttling data between machines, and your own prompts are answered on your own hardware before the network is involved.

Only when idle

Powered, idle, and out of your way

On a PC: powered, on an unmetered connection, and not in use. On a phone: charging, Wi-Fi, screen off, above 80%. Gated to conditions where you'd never notice it, and one switch turns it off with no dialog that argues and no retention flow.

Around the clock

Somewhere it's always 3 a.m.

Demand peaks during the working day; supply peaks overnight. Since night circles the planet continuously, the network is always fed by the hemisphere that's asleep — and never drops below about 14% of the fleet.


Security

The network never runs arbitrary code on your machine.

A job is a prompt plus a task name — never a script, a program, or a container. On phones and PCs alike. That removes crypto mining, password cracking, malware, and using your connection as a proxy — not as a rule we promise to enforce, but because there is no way to run them.

Layer 0, the foundation: inference only, no arbitrary code ever, on PCs exactly as on phones. Below it a trust ladder showing what each machine may do alone: an attested phone may do any work including answering alone; a PC with TPM 2.0 or Secure Enclave answers alone once reputation is earned; an unattested PC — the largest tier — does corroborated work only, permanently; anything behaving anomalously is served nothing. Unattested machines are never excluded, only never trusted alone. Trust is earned through canaries and silent re-checks, bounded by the fact that a Sybil attack buys identity but not capacity, and made pointless by there being nothing to cash out. Not solved: whoever runs a machine can read what it processes.
Defence layers — and what they don't solve
The foundation

Inference only. No exceptions.

Competing networks run general-purpose runtimes to be flexible. That flexibility is exactly the attack surface. We trade capability for safety here, permanently.

Is the work real

Hidden known-answer tasks

Jobs whose correct answer we already know, mixed in indistinguishably. You can't tell one from real work, so the only way to pass is to actually compute. Plus silent spot re-checks against a trusted machine.

No prize to win

Nothing to cash out

Credits can't be sold or transferred, so a fake fleet's earnings are stranded. Almost every attack on networks like this is financially motivated. Remove the money, remove the motive.

What this does not solve

  • Whoever runs a machine can read what it processes. Running a model requires the text in memory. Only specialised secure hardware fixes this, and coverage is patchy across the mid-range devices that make up most of the fleet. We reduce it structurally — a machine never learns who asked, and consecutive turns of a conversation go to different machines — but we won't promise privacy the design can't deliver.
  • The catalogue is a real limitation. Because we can't run submitted code, the network can only compute things we've already built. A researcher can't bring a novel simulation; they request a task type and wait for a release.
  • Fake-identity attacks are bounded, not solved. Nobody has solved that without either a trusted registry or money at stake, and we've ruled out money.
  • Nothing here has been audited. Until an outsider has tried to break it, treat all of it as intent rather than proof.

The compute economy

Earn compute by giving compute. No money crosses here.

Contribute hours, not horsepower — a four-year-old phone earns what a 24GB graphics card earns. That yields credits, a usage allowance for verified work only, capped per machine per day and decaying so it never becomes savings. Credits are spent on priority, longer context, access to the bigger models only PCs can host, and the right to submit your own batch job against an audited task. The obvious objection is answered: paying by speed would hand the most free AI to whoever already owns the best hardware, so recognition is weighted by contribution but allocation never is. Below, an unconditional free floor for everyone at zero balance forever. Separately, actual money: institutions and companies buy batch time from surplus only, every buyer named, no single buyer above 25 percent of revenue, funding hosting, audits, and research grants on a public ledger. Contributors are never paid.
Earn compute by giving compute — and the separate ledger where money lives
Contribute

Hours, not horsepower

Credits accrue for reliable overnight availability. A four-year-old phone earns the same as a new flagship — because paying for speed would hand the most free AI to the people who need it least.

Credits

A usage allowance

Verified work only. Capped per device per day. Decays over months so it never becomes savings. Can't be bought, sold, transferred, or cashed out — and never a vote.

Spend

Priority and headroom

Queue priority, larger models, longer context — and the right to submit your own batch job. That last one is the real economy: a researcher with no budget earns compute instead of buying it.

The floor · unconditional

Free access for everyone, at zero balance, forever

Credits buy priority and headroom — never access. If the free tier ever degrades to make credits attractive, the project has failed.

Where actual money lives — a separate ledger

Institutions and companies buy scheduled overnight batch capacity in ordinary currency, drawn only from surplus. That revenue covers hosting, audits, developer time, and a research grant pool that gives free capacity to scientists who can't pay. Nine rules keep it honest:

  • Public ledger and public buyer register. Every payment in, every expense out, every buyer named. Anonymous corporate compute purchasing isn't available at any price.
  • Surplus only, never preempting free access — even at peak.
  • Paying buys compute and nothing else. No routing preference, no roadmap influence, no governance seat, no veto. Buyers are customers, not stakeholders.
  • No single buyer above 25% of revenue. A funder big enough to end the project by leaving is a governance problem regardless of how they behave.
  • Contributors are never paid. Which is what keeps them volunteers rather than unlicensed contractors.

Why not split that money among contributors? We costed it: a phone earns about $1.32 a year and burns $1.58 of its owner's electricity to do it. In most of the world you'd be paying us to participate.


Honest limits

What this will never do.

Every project in this space leads with what it can do. Here's what physics forbids, stated up front — because a plan you can't poke holes in isn't a plan.

  • It is not one giant brain. Splitting a single large model across machines on the internet fails — generating each word means passing data through every layer in sequence, and network hops are millions of times slower than the wiring inside a chip. So we don't split models at all.
  • It will not train frontier models from scratch. Training needs terabytes per second of bandwidth between processors sitting inches apart. No amount of adoption changes that. Fine-tuning an existing small model is a different, achievable problem.
  • The compute is throughput, not one pooled engine. Millions of independent tasks at once — not a single task made a million times faster. A million couriers, not one cargo jet.
  • Data centers batch; we can't. A data center reads the model once from memory and serves hundreds of people with that read. A phone reads it once per word, for one person. Per piece of hardware they're far more efficient at this. Our advantage is that the hardware is already bought and the next answer costs nothing.

Corrections

Where we've been wrong so far.

Two of this project's own claims have been retracted, and they're listed here rather than quietly deleted. If the numbers above are worth anything, it's because of how the ones below were handled.

ClaimPreviouslyCorrected
Adoption needed to pass the largest data center 1.4% — 30M phones Not reachable at any adoption level
Cheating caught by comparing machines Deterministic, so exact match works Only within identical hardware — canaries and re-checks instead
Phones that can run a small model, today 2.2 billion 1.2 billion (2.2B is a ~2030 figure)
Devices available overnight 95% 60% — charging and Wi-Fi and undisturbed
Availability floor ~33% of the fleet 14.1%

The first was a bad number: running an AI model is limited by memory bandwidth, not processing power, so a chip advertising 45 trillion operations per second sustains about 0.098. The second was worse — a wrong mechanism, which would have accused honest volunteers of cheating.

Every figure on this site is generated by one script you can run yourself. Find another error and we'll publish that too.


Open questions

Five things we haven't figured out.

Listed because pretending they're settled would be the actual problem.

  1. Who pays for it. The plan is institutional and corporate batch buyers. Nobody has agreed to anything yet. The early phases have to be affordable to run unfunded, and they are — but the funding model is unvalidated.
  2. Battery health over years. We gate on temperature and charge level, which covers what we can control. Nobody has multi-year data on nightly compute loads on phone batteries, and we won't for at least a year. If an unquantified risk to your hardware isn't acceptable to you, don't install it — that's a reasonable position.
  3. iOS. Background execution limits effectively forbid this. An iPhone can realistically only contribute with the app open and charging. Android and desktop first; we're not going to claim a parity the platform doesn't allow.
  4. Build the stack, or ride someone else's? Acurast already has 250,000+ phone nodes and a working network. Owning the consumer app and the mission on top of their compute layer is a live option we haven't decided against.
  5. How the task catalogue stays legitimate. Because we can't run submitted code, we decide what the network is capable of. That's more power over its purpose than we're comfortable with. A public request process with a mandatory comment period constrains it imperfectly.

The promise

No token. No wallet. No ads. Ever.

Most decentralized compute networks pay contributors in cryptocurrency and sell the compute back to developers. Moonlight isn't a marketplace. It's a public utility: free to use, free to join, and open source end to end. Whatever eventually pays the hosting bill, it will never be your access, your attention, or your data.

If you ever see a Meridian Moonlight token for sale anywhere, it's a scam — and we'd appreciate the heads-up.


Roadmap

Every phase ships something that runs.

M0

One node lives Next

A phone and a desktop each run a model overnight. Three deliverables matter more than the code: measured speed, watts and heat; where identical hardware actually produces identical answers; and a sixty-second video of it working.

Both tiers · Month 0–1
M1

The network answers

Work routes between volunteers' machines, with known-answer canaries, spot re-checks, reputation scoring, and a live map of who's online.

~100 machines · Month 1–3
M2

Follow the moon

Region-aware routing, the measured 24-hour availability curve published against the modelled one, and the first real overnight science job.

~10K machines · Month 3–9
M3

Open protocol

Specification v1.0 so anyone can build a compatible node — or run a competing coordinator without asking us. Plus governance, a legal structure, an external security audit, and the first research partner. If this spec doesn't ship, our "centralized for now" defence was a rationalisation.

~100K machines · Month 9–18
M4

Public utility

Full peer-to-peer discovery and a standing institutional research programme. A network no single party can switch off.

1M+ · Month 18+

Join

There's nothing to install yet. There's plenty to help with.

No sign-up form, no mailing list, no pledge to make. Send an email and a person replies. Tell us what machine you have and what you'd like to do — that's genuinely the information we need most right now.

Opens your email app with a short template. Or write to hello@meridianmoonlight.com directly. Nothing is stored on this site — it has no database and no tracking.