Lisa Blog

Lisa Core: the daemons that hold every authority

· The Lisa team
corerustdaemonsarchitecture

Every Lisa flavour, desktop or server, stands on the same thing: Lisa Core. Core is the services: the daemons that hold every authority on the machine, the libraries they share, the document portal, and the lisa command. It is one Rust workspace, released once, and every flavour’s image is built on top of it.

The desktop is what you see. The base is the Fedora system underneath. Core sits between them, and it is where Lisa decides what is allowed.

One authority, one owner

The idea behind Core fits in one sentence: every authority on the machine has exactly one daemon that holds it, and nothing else can exercise it.

daemon the one thing it owns
sessiond what runs. It launches every application, keeps the roster of what is installed, and is the only thing in a session that executes anything.
settingsd preferences. A typed registry with generations, repair and migrations; an app reads and writes its keys, never a file of its own.
consentd asking you. The one process that draws a confirmation, a permission prompt or an administrator’s authorisation, and keeps what you granted.
updated updates. An authenticated check of the release channel, a verified staging in the background, and the restart.
remoted leaving the machine. The only process that talks to a remote model provider.
agentd agents. Every agent action goes through its state machine, with its tier and provenance enforced and an undo journal.
deviced devices. Network, power, Bluetooth and location, typed over NetworkManager, UPower and BlueZ.

Each daemon has a page of its own in the docs: what it holds, the files it owns, its states, and what it does when it restarts.

Why so strict? Because an authority with two owners has no owner. If two processes can launch applications, neither can promise that every launch is checked. If an application can draw its own permission prompt, any application can draw a fake one. If several processes can reach the internet on an agent’s behalf, nobody can say what left the machine. Giving each authority to exactly one daemon makes each of those promises checkable.

It also shapes how the daemons are locked down. On a server, only Bridge listens on the network, and every other daemon is denied the network in its own unit. The rules for who may call whom live on the bus, in policy files Core ships, not in each daemon’s goodwill.

Contracts, not conventions

The daemons speak dev.lisaos.* over D-Bus, and each interface is a contract in the docs: its methods, its errors, and the invariants it keeps. The Rust server side and the Dart client side are both generated from that contract, so the system and its applications cannot drift apart without the build failing. An application never hand-writes a bus call. It uses the generated client from Lisa’s SDK.

Open by design

Core is the one part of Lisa meant to be open source. It is licensed Apache-2.0, and every other Lisa repository is proprietary. The rule is simple: anything meant to be open goes into Core, and nothing else grows an open licence by accident.

Being open means being careful about what Core depends on, so a licence gate runs with every check. It verifies Core’s entire locked dependency tree, including build and development dependencies, against an explicit list of permitted licences: Apache-2.0, MIT, ISC, the BSD family and a few others. A GPL-only or AGPL-only crate fails the build, and so does one with no licence declared. There are no blanket exceptions. The gate is tested with real failing cases, not just a parser of licence strings.

We should be honest about one thing: the repository is still private today. The Apache-2.0 licence is in place, and making the repository public is the step that remains.

Tests that never trust the clock

Core’s tests run on a build machine that is rarely idle. That taught us a rule the docs now state outright: a test never depends on the wall clock.

We learned it from a real failure. Two download-deadline tests passed alone and failed under load. Their time margins had already been widened twice, and a third widening would only have moved the load at which they failed. So now code that keeps a deadline reads time through a seam: the real clock in production, a virtual clock in its tests. The tests advance that clock instead of sleeping. A test that passes alone and fails under load is a bug in the test, and it is fixed, never re-run until it happens to pass.

How it ships

Core is built once per architecture as its own image. Each flavour’s image is built from Core’s pinned digest, adding what that flavour needs: the compositor and desktop for Lisa Desktop, serverd and Bridge for Lisa Server. Core’s daemons run everywhere; a flavour’s own daemons join only its image.

What is not done

The docs keep a running list, and the main items today are:

  • The daemon table is behind the image. The installed release runs sixteen daemon programs, more than the table on the Core page lists as built. And one daemon it lists, containersd, is not on the desktop image. The table needs a fresh audit.
  • Several specified daemons have no code yet, including the context store and the model store. Their pages and contracts exist; their programs do not.
  • The hardware conformance collector is partial. It records read-only probes, but two tiers stay pending until their real proofs exist.
  • Not every test is off the wall clock yet. The download code is; the rest of the workspace still has to be read test by test.

All of it is on the Core page and gathered with everything else at docs.lisaos.dev/gaps.

← All posts