Getting started with Lino

Prerequisites

Before installing Lino, check that your environment is properly prepared:

• ✅ .NET 10.0 SDK or higher installed. Download .NET
• ✅ .NET CLI available in the terminal. Check with: dotnet --version
• ✅ Git installed for version control. Download Git
• ✅ Entity Framework Core CLI installed for migrations support: dotnet tool install --global dotnet-ef
• ✅ OCI-compatible container environment, such as Docker Desktop or Podman.

Platform Compatibility

Lino is cross-platform and can be used on the main operating systems:

• ✅ Windows
• ✅ macOS
• ✅ Linux

Installation

Lino is distributed as a global .NET tool. Before continuing, make sure you have the .NET 10 SDK or higher installed.

To install the latest version, run:

dotnet tool install --global Tolitech.Lino

After installation, validate that Lino is working by running:

lino --version

If the installation succeeds, the installed version will be displayed in the terminal.

Authentication

After installing Lino, you must authenticate to access all features.

If you already have an account, log in with the command:

lino auth login

You will be asked to provide:

• Username: Previously registered email address.
• Password: Password associated with the account.

If you do not have an account yet, register directly through the CLI using:

lino user register

During registration, provide:

• First name: User's first name.
• Last name: User's last name.
• Email: Email address that will also be used as the login.
• Password: Secure password with at least 6 characters.
• Password Confirmation: Enter the password again for validation.

When registration is completed, the user will be authenticated automatically.

Language preferences

By default, the Lino CLI is displayed in English en, but you can change the language according to your preference among the available options:

en | pt | es | de | fr | it | ja | ko | ru | zh

To set a new language, run the following command:

lino preferences culture set --name <culture>

Replace <culture> with one of the supported cultures. For example, use pt for Portuguese, en for English, or es for Spanish.

Alternatively, you can select the language from an interactive list with:

lino preferences culture set

UTF-8 encoding adjustment (optional)

For correct display of languages with special characters (such as Japanese, Korean, Russian, or Chinese), make sure your terminal is configured to use UTF-8 encoding.

In Windows PowerShell, adjust the encoding by running the following commands:

[console]::InputEncoding = [System.Text.Encoding]::UTF8

[console]::OutputEncoding = [System.Text.Encoding]::UTF8

Note: On Linux, macOS, and Windows Terminal, UTF-8 support is usually native. Even so, it is recommended to validate the configuration if any character display problem occurs.

Available commands

Lino organizes its automation into command groups. Each group represents an architectural intent: creating the solution, adding services, modeling the domain, exposing APIs, generating pages, configuring integrations, controlling migrations, versioning artifacts, and preparing builds.

The most reliable reference for your machine is the help from the installed CLI itself. Use lino --help to see the full command tree and use --help on any group to check options, aliases, required parameters, and examples.

Because Lino evolves continuously, new commands and options can appear between versions. Treat this documentation as usage guidance and confirm the exact syntax in the terminal whenever you automate a workflow or train someone on the team.

To display the available command list, run the root command or ask for help explicitly:

lino
lino --help

lino --help
lino project --help
lino database migrations --help
lino integration operation --help

To inspect subcommands and options for any group, use the command name by itself or combine it with --help:

lino <command>
lino <command> --help

For example, when checking the project group, the CLI shows the group description, common examples, and available subcommands:

lino project --help

DESCRIPTION:
    Manages Lino projects.

EXAMPLES:
    lino project new --name MyProject
    lino project list

COMMANDS:
    new     Creates a new project.
    list    Lists created projects.
    delete  Removes an existing project.

When reading examples, values between <...> indicate arguments that must be replaced with the real value from your project. For example, <ProjectName> must be replaced with the solution name, <ServiceName> with the service name, and <culture> with a supported culture such as pt or en.

Main command groups:

Some commands show a short alias in parentheses for convenience. The original names remain the main reference for reading, documentation, training, automation, and support.

Quick Start

Quickly create a modern, scalable .NET application prepared for continuous evolution with the following command:

lino project new --name <ProjectName>

Replace <ProjectName> with the real name of your solution. For example, to create a project named MyApp, run lino project new --name MyApp.

This command generates a .NET solution structured with clear separation between domain, application, infrastructure, persistence, API, orchestration, and tests. The initial structure helps keep architectural decisions visible from the first commit, preventing business rules, data access, endpoints, and operational details from being mixed in the same place.

Visually, an initial solution named MyApp can be understood like this:

MyApp/
├── MyApp.slnx
├── src/
│   ├── Aspire/
│   │   ├── AppHost/
│   │   │   └── MyApp.AppHost.csproj
│   │   └── ServiceDefaults/
│   │       └── MyApp.ServiceDefaults.csproj
│   └── Services/
│       └── Shared/
│           ├── Api/
│           │   └── MyApp.Shared.Api.csproj
│           ├── Application/
│           │   └── MyApp.Shared.Application.csproj
│           ├── Domain/
│           │   └── MyApp.Shared.Domain.csproj
│           ├── Infrastructure/
│           │   └── MyApp.Shared.Infrastructure.csproj
│           └── Infrastructure.Persistence/
│               └── MyApp.Shared.Infrastructure.Persistence.csproj
└── tests/

This tree is a teaching example of the structure generated for the user's project. It shows how the solution separates local execution, services, technical layers, and tests from the beginning.

What the initial project provides

The initial solution created by Lino is already organized by technical responsibilities. Instead of delivering only an empty project, the CLI prepares a foundation with layers and components suitable for enterprise applications.

The name provided in <ProjectName> becomes part of the solution's technical identity. Choose a short, stable, and representative name, because it will be used in namespaces, assemblies, artifacts, configurations, and references between components.

Main benefits:

• Explicit architecture: separation between business rules, use cases, infrastructure, persistence, and input contracts.
• Modular evolution: foundation prepared for traditional services, modular monoliths, microservices, and SaaS applications when the context requires it.
• Consistent technical patterns: support for DDD, Clean Architecture, CQRS, events, integrations, migrations, tests, and observability.
• Less mechanical work: generation of repetitive structures so the developer can focus energy on domain, rules, contracts, and product decisions.
• More predictable code: naming conventions, folder organization, and responsibilities reduce ambiguity among team members.

With Lino, the developer does not start from an empty folder or from a generic template. They start from an opinionated foundation designed for enterprise systems, where each generated artifact has a clear technical function and can be evolved incrementally.