Windows

Lific runs natively on Windows. The server, web UI, CLI, REST API, MCP server and automatic backups all work, SQLite is compiled into the binary, and lific login keeps its tokens in the Windows Credential Manager. The published Windows binary targets x86_64-pc-windows-msvc.

lific init also sets up a background service, as it does on Linux and macOS: the server starts when you sign in, restarts if it crashes, and needs no administrator rights. The background service explains how it works. The Linux binary also runs under WSL 2, covered at the end of this page.

Install

Download lific-windows-x86_64.exe and sha256sums.txt from the releases page, then verify the download in PowerShell:

$expected = (Select-String -Path sha256sums.txt -Pattern 'lific-windows-x86_64\.exe').Line.Split(' ')[0]
$actual   = (Get-FileHash lific-windows-x86_64.exe -Algorithm SHA256).Hash
if ($actual -ieq $expected) { "checksum ok" } else { "checksum MISMATCH" }

Rename it to lific.exe, put it in a directory on your PATH, and check it:

lific --version

Or install with Cargo

Cargo builds Lific from source on your machine, which is also the way to try an architecture the releases do not cover.

Install rustup from rustup.rs and keep the default MSVC host toolchain (stable-x86_64-pc-windows-msvc), which needs the Visual Studio C++ build tools. The rustup installer offers to install them. If you skip that, install the "Desktop development with C++" workload from the Visual Studio Build Tools installer.

cargo install lific

Lific needs Rust 1.88 or later. The crates.io package carries the prebuilt web UI, so Bun is not involved. Compilation takes several minutes and the binary lands in %USERPROFILE%\.cargo\bin\lific.exe, which rustup already put on your PATH.

Create the instance

lific init

init creates the instance, installs the background service, starts it, and waits up to 15 seconds for the server to answer. Pass --no-service to skip the service and run lific start in a terminal yourself.

init asks for your name and how people should sign in. Login-free mode writes [auth] required = false, pins [server] host to 127.0.0.1, turns on browser auto-login and creates a passwordless administrator. Password mode leaves the bind host alone, keeps authentication on, and asks for the administrator's password. Quickstart describes the choice, and --auth-mode, --name and --password make it non-interactive.

On Windows, init writes both files under your roaming profile:

Attachments and automatic backups go next to the database, in %APPDATA%\lific\attachments and %APPDATA%\lific\backups. Add --here to init to keep the whole instance in the current directory instead, as .\lific.toml and .\lific.db.

Open the web UI

After init, the server is already running on the default port, 3456. Open http://127.0.0.1:3456 and sign in as the administrator init created.

To run the server in the foreground instead (for debugging, or after init --no-service), use lific start. Ctrl+C stops it. Stop the service first with lific service stop, because only one server can listen on the port.

The built-in default bind host is 0.0.0.0, which accepts connections from your local network, so Windows Defender Firewall asks for permission the first time. Login-free initialization already wrote 127.0.0.1. Otherwise set it yourself if this instance is only for you:

[server]
host = "127.0.0.1"
port = 3456

From here the rest of the Quickstart applies unchanged: connect your AI tools with lific connect, then create a project and an issue.

The background service

lific init and lific service install add a value named Lific under HKCU\Software\Microsoft\Windows\CurrentVersion\Run, your account's list of programs to start at sign-in. The value runs lific --config <path> service run, which starts a small supervisor and exits. The supervisor runs lific start for that configuration, restarts it if it exits with an error, and appends the output of both to lific.log in the instance directory (%APPDATA%\lific\lific.log by default).

Manage it with the same commands as on the other platforms:

Follow the log with Get-Content -Wait lific.log in the instance directory. Lific moves the log to lific.log.1 when it passes 10 MB.

A server that keeps exiting with an error is restarted at most five times in 60 seconds, two seconds apart. After that the supervisor writes "giving up" to the log and exits. Fix the cause the log shows, then run lific service restart. A server that exits cleanly is not restarted.

Nothing here needs administrator rights, Task Scheduler, or PowerShell. It works on machines whose policy stops standard users from creating scheduled tasks.

Things to know:

• Console window. On Windows 11 24H2 and Windows Server 2025 and later, nothing appears at sign-in. Older versions show a console window for a moment while the supervisor starts.
• Sign-in, not boot. The server starts when you sign in and stops when you sign out. Lific does not install a Windows service that runs before anyone signs in, because that needs administrator rights.
• Task Manager. The entry appears under Startup apps in Task Manager. Disabling it there stops the server from starting at sign-in; lific service status still reports it as installed. Some managed machines ignore the Run list entirely through Group Policy. On those, the entry is written but never starts, and lific start in a terminal is the way to run the server.
• Upgrading. Windows cannot replace a program file while it runs. Run lific service stop before you replace lific.exe or run cargo install lific, then lific service restart. If the new binary is at a different path, run lific service install instead.
• One per sign-in session. If the same account is signed in twice at once, for example at the console and over Remote Desktop, each session starts its own service, and the second one's server cannot bind the port.
• Path length. Windows runs at most 260 characters of a Run entry. If the paths of lific.exe and your configuration are longer than that together, install refuses and asks for a shorter location.

WSL 2

WSL 2 runs the Linux release binary, and lific init there installs a systemd user service.

Install a distribution if you do not have one:

wsl --install

Inside the distribution, confirm systemd is on. /etc/wsl.conf must contain:

[boot]
systemd=true

Recent Ubuntu WSL images ship with it enabled. If you add it by hand, run wsl --shutdown from Windows and reopen the distribution.

Then follow Installation for Linux: download lific-linux-x86_64, verify it, make it executable, put it on your PATH, and run lific init. The service step works because systemd is there.

WSL forwards localhost, so http://localhost:3456 answers from a Windows browser while WSL is running. That caveat is the real one: WSL shuts its virtual machine down once no sessions or processes remain, and the server goes with it. Keep a WSL terminal open, or start the distribution before you need the tracker.

Build from source natively

A native source build needs Rust 1.88 or later, the Visual Studio C++ build tools and Bun. Build the web UI first, because build.rs refuses a release build when web\dist\index.html is missing:

git clone https://github.com/VoidNullable/lific
cd lific
cd web; bun install; bun run build; cd ..
cargo build --release

The binary is written to target\release\lific.exe.

The published Windows artifact is built differently: it is cross-compiled on Linux for the same MSVC target through the repository's release-windows-msvc devenv profile, then downloaded onto a Windows runner that checks its checksum and exercises its startup, database, API and embedded frontend before the release is published. Native Windows Clippy and cargo test --all-targets run as their own CI job on every push.