What shipped.

Version 0.3.0

Version 0.3.0 opens the early beta and deploys a whole architecture. A project now holds several apps, and LILY reads the connections between them out of your code.

LILY reads the repository first

Connect a repository through GitHub and LILY finds every deployable app inside it. Each app is configured, managed and deployed on its own.

The same scan picks up the environment variables each app expects, the network connections between apps and the database references. LILY pre-fills the configuration from what it finds and assigns each database to the apps that use it. Deploy the apps together or one at a time.

See what talks to what

The project view draws your apps as a graph of their connections. You decide which of those paths are allowed, and which apps may reach services outside the platform.

New in 0.3.0

• Multi-app projects. A project holds several applications.
• Monorepo detection. LILY finds the deployable apps inside a repository.
• Configuration detection. Environment variables, network dependencies and database references are proposed for you.
• Pre-configured networks. Connections LILY detects are ready at deploy time.
• Pre-configured databases. Each database is assigned to the apps that use it.
• Application flow view. A graph of every connection between your apps.
• Network rules. Set which apps may talk to each other and to external services.
• Build and deploy logs. Every build and deployment writes its log to the platform.
• Per-app control. Stop and start each app on its own.
• Repository import by auth token. Register a repository with a token before you sign up and import it afterwards.

Version 0.2.11

Most of this release sits below the interface. We rebuilt the parts the first weeks of the beta showed were weak: communication between our control nodes, the update path, the runtime and the compiler.

Apps keep serving when management fails

The servers that run your apps now operate on their own. If the system that manages them goes down, your apps keep answering requests.

Building, deploying and managing an app now run through one pipeline.

Rust joins C and C++

C, C++ and Rust compile and run in full. JavaScript and TypeScript run with Next.js and Node, and coverage grows with each release.

New in 0.2.11

• Rust. Compiled and run in full, alongside C and C++.
• Node. JavaScript and TypeScript beyond Next.js.
• Independent servers. Running apps no longer depend on the system that manages them.
• One pipeline. Build, deploy and management share one path.
• New interface. The platform UI is redesigned.

Version 0.2.10

The documentation is public at docs.lilylabs.io. Each docs release carries the version it was built from, so you can tell which state you are reading.

New in 0.2.10

• Public docs. At docs.lilylabs.io.
• Versioned releases. Every docs deploy names the version behind it.

Version 0.2.9

LILY is open. Anyone can sign up for the alpha and run a Next.js application on our infrastructure.

From repository to a live address

Point LILY at a Git repository. It builds and deploys the app, then serves it on a subdomain you reserve.

There is no Dockerfile to write.

New in 0.2.9

• Open sign-up. The alpha needs no invitation.
• Next.js. Next.js applications run on LILY.
• Deploy from Git. Reference an application straight from its repository.
• Automatic build and deploy. The repository becomes a running app without manual steps.
• Your own subdomain. Reserve one and the app answers there once it is live.

Version 0.2.5

Most products are several services. Version 0.2.5 groups them into projects, managed as one system.

One set of rules per project

Network rules and shared settings apply to the whole project. Decide once which services may talk to each other, and the rule covers every service in it.

LILY recognises the network routes between your apps on its own, inside a monorepo or across separate apps.

New in 0.2.5

• Projects. Group several services into one application.
• Project-wide network rules. One decision on which services may talk to which.
• Automatic network routes. Routes inside a monorepo or across apps are recognised for you.
• Shared configuration. Settings that apply to every service in the project.

Version 0.2.0

Version 0.2.0 closes the path from code to a running app. LILY compiles the app, places it on a machine and serves it on its own subdomain.

How a deploy works

Hand an app to the platform. It picks a machine, starts the app there and gives it a subdomain. The app answers from that moment, and the platform lists every app you run.

New in 0.2.0

• End-to-end deploys. Source in, running app out.
• Your own subdomain. Every app has its own address.
• App overview. Every app you run, in one list.
• Accounts. Sign in once and deploy from there.

Version 0.1.0

LILY compiles your app into small units that run directly on the machine. That takes a compiler per language, so the compilers came first.

New in 0.1.0

• C and C++. Full support, standard libraries included.
• JavaScript. A dedicated compiler for dynamic code.
• Next.js. Built on the JavaScript compiler.