Deploy your app anywhere. Source code is unreadable.
LockFlare's flagship. Cipher deploys the applications you already have — a Node.js or .NET backend, a built frontend, a native binary — to any Linux server, stored as AES-256 ciphertext, decrypted only in memory, never written to the server's disk in the clear. Confidential computing without the silicon.
Three tiers, one flow
Cipher is the product LockFlare was founded on and the engineering Lens grew out of: a desktop app, a control API, and an engine on each server. The app is where you work; the engine is the only thing on the box; the API is the thing in between.
The app
On your Mac or Windows machine. Import a project, pick an environment, push: the folder is zipped in memory, encrypted with AES-256-GCM, and uploaded as ciphertext. Your source folder is never modified and nothing readable leaves the machine.
The control plane
Holds environments, servers, users and the audit log. It routes encrypted builds to the engines and keys each build to the machines licensed to run it; plaintext is never part of its job.
The engine
One binary per server, installed in a two-minute terminal session with a license key. From then on the machine is a runtime: it pulls the encrypted build, decrypts it in RAM, and serves. Restart the server and it pulls again; nothing irreplaceable lives on it.
The engines
An environment is created with one runtime and keeps it for life. Each runtime loads code from memory, not from a path.
Node.js
Your backend runs inside a per-domain sandbox built on Node's own vm: the decrypted bundle is compiled from a buffer and executed in an isolated context that never touches the filesystem for source. Standard workers (one real worker per licensed core), an emulated cluster in one process, or a single instance — chosen per project.
.NET 10 and later
Published ASP.NET Core apps — Razor Pages, Blazor Server, minimal APIs — are loaded from memory into collectible assembly load contexts, compiled through Roslyn where needed, and swapped atomically on redeploy with no process restart and no dropped connection.
Native
Go, Rust and C ship as encrypted binaries through the same pipeline and are executed from memory under the engine's supervision. Same push, same environments, same audit.
Frontends
Any build that produces a folder — Vue, React, Angular, Svelte, Next.js static export, Nuxt, Astro — is pre-compiled into an in-memory site bundle and served by the engine. A mixed project combines a backend and its built frontend at push time.
Hot reload
A redeploy lands as a new in-memory image and an atomic swap: the old image serves until the new one is ready, then steps aside. Zero-downtime by construction, not by a rolling script.
Environments and fleets
An environment is a set of servers running the same code — Development, UAT, Live, or a client grouping. One push lands on every server in it, and each server confirms independently. Bind as many domains as you need; the fleet serves them all from one in-memory application.
Server Enclave: seal the server, keep it serving
Sealing disables every login on the machine — SSH, console, KVM, IPMI, the hosting panel — while sites, APIs and hot deploys continue. Every seal and unseal is authorized by two-factor authentication and an HMAC-SHA256 single-use nonce; a stolen session token cannot do either. The seal survives reboot: the engine detects the sealed state on boot and keeps it.
Their hardware, your seal. The hosting team can rack, reboot and monitor the machine; nobody can log in, read or copy code, tamper with the runtime, or bypass licensing. What Nitro Enclaves and SGX do with custom silicon, Cipher does in software, on any Linux server, at any provider.
What it is for
SaaS delivered on-premises
An enterprise client demands on-prem and you cannot hand over your source. Install the engine on their servers: your code runs there, fully functional, completely unreadable. License per server, keep the IP, turn the deal you would have walked away from into recurring revenue.
Outsourced development
Your vendor builds, tests and deploys in Cipher. It runs on your servers. They cannot extract the source, and when the contract ends the IP stays with you.
Regulated industries
Government, defense, healthcare, finance: environments where source is classified or residency is strict. Air-gapped deployment, self-hosted storage, your keys in the loop.
Disposable infrastructure
Hardware fails. Nothing irreplaceable lives on the machine: provision a new server, install the engine, and the platform pushes your whole stack. Recovery is not a restore. It is a fresh install.
Users, permissions and the record
Granular permissions
Per project and per action, with where and when a user may sign in. A vendor can deploy without ever being able to extract source.
Every action on the record
Pushes, reloads, seals, permission changes: a complete per-project log of who did what and when, filterable per project and per user, for the compliance conversations you will actually have.
Licensing as a security instrument
Each server holds a license bound to its own address; it is how builds are keyed per machine. Remove it and the machine can no longer decrypt anything.
Signed and notarized
The app ships for macOS and Windows under LockFlare Corp's signing identities; the engine is a single Linux binary.
The technical documentation
Everything below is written for the engineer who will run it, not for the buyer: what is packed, how it is encrypted, what the engine does on boot, and what each runtime cannot do.
How it works
Pack, encrypt, deliver, execute — the four stages, and the one that produces readable code.
The three pieces
The desktop app, the control plane and the engine, and what each one can and cannot see.
Understanding a LockFlare server
What is on the box, what is in memory, and what happens on a reboot.
The Node engine
Installation and configuration for Node.js backends and the worker models.
The .NET engine
Installation and configuration for ASP.NET Core, Razor Pages and Blazor Server.
Enclave
Sealing and unsealing a server: the two-factor step, the nonce, and what survives a reboot.
Server requirements
Ports, memory, distributions, and what the engine needs to reach.
Known limitations
What running from memory rules out, for both runtimes and for each.
All of the documentation
Thirty-nine pages: the app screen by screen, the engines, the limits, troubleshooting.
Cipher is not a public download
It makes source code unreadable on the server that runs it, so we want to know who is running it: Cipher is licensed on request, to companies we have spoken with, for the applications they name. Write to us with what you deploy, where, and to whom, and we will walk you through it on your own servers.