Development Roadmap

This update will ensure full support for generating projects based on .NET 10 as soon as the new version is officially released by Microsoft.

Currently, Lino generates projects based on .NET 9, leveraging all available platform features, including performance improvements, advanced C# 13 features, and modern integration with ASP.NET Core.

The goal of this future version is to provide immediate support for .NET 10 with updated templates, appropriate Target Framework configurations, and scaffolding ready for the new language and runtime features.

Automated test generation with support for two main levels:

Unit Tests:
Creation of tests for individual classes and methods, focusing on business logic.

Integration Tests:
Creation of tests to verify integration between components, simulating interactions with databases and external services.

Implementation of automatic generation of .http files to facilitate testing and documentation of REST endpoints in development environments.

Permission-based access control system (PBAC) using ASP.NET Core Policies.
Permissions are automatically generated by Source Generators and registered as Policies in .NET.
Each service using these permissions triggers events that automatically feed and update the system's permission database.

Key Features:
_ Automatic permission generation via Source Generators
_ Automatic registration of Policies in ASP.NET Core
_ Dynamic update of the permission database via events/messaging
_ Hybrid RBAC support, combining role simplicity with permission granularity

Benefits:
_ Maximum performance and scalability
_ Automated management and simplified maintenance
_ Flexibility for different security scenarios

Implementation of native support for the IFormFile type in endpoints created with Minimal APIs. This feature enables automated route generation with file upload support, including:

_ Definition of endpoints supporting uploads via multipart/form-data;
_ Automatic validation of MIME types and allowed maximum sizes;
_ Support for local storage and integration with cloud services like Azure Blob Storage and AWS S3;

Ideal for applications that require secure and high-performance file uploads such as images, documents, and general media.

Starting from this version, Lino CLI performs smart automatic merging of generated files. Previously, files created by Lino would directly replace existing ones, potentially overwriting manual changes made by the developer.

Now, with the new 3-way merge strategy (original generated file, user-edited version, and new generated file), Lino can preserve customizations while applying structural updates from the template.

Benefits of this approach:
_ Prevents accidental overwrites of manual code.
_ Facilitates continuous evolution of template-based projects.
_ Reduces manual conflicts during updates.
_ Improves integration between local customizations and framework evolution.

Now, projects generated by Lino CLI can automatically register Minimal APIs using the Tolitech.Presentation.API.Generators library, which is based on Source Generators.

This approach replaces the need to:
_ Manually register each endpoint using MapGet, MapPost, etc.
_ Use Reflection to scan and map routes — which is costly in terms of performance.

With Source Generators, the mapping is done at compile time, generating optimized, clean, and traceable code.

Key benefits:
_ Eliminates verbosity and repetition from manual route registration.
_ Removes the need for Reflection, reducing CPU and memory usage.
_ Improves code organization and separation of concerns.
_ Automatically and safely generates routes with compile-time validation.
_ Eases project maintenance and scalability.

We now use the Tolitech.DependencyInjection.Generators library, which replaces the Reflection-based approach of Tolitech.DependencyInjection.Extensions.

This new library leverages the .NET Source Generators feature to automatically generate dependency registrations at compile time.

This provides several advantages:
_ Elimination of runtime Reflection, improving application performance.
_ More predictable and traceable code generation.
_ Safer compilation with early error detection.
_ Native integration with the .NET build pipeline.

We have adopted the Central Package Manager (CPM), a modern approach to managing NuGet packages in solutions with multiple projects. With it, all package versions are centrally defined in the Directory.Packages.props file, eliminating inconsistencies and enabling safe, coordinated updates. This reduces errors caused by version mismatches between projects, improves traceability, and simplifies large-scale dependency updates.

Lino now generates solutions in the new .slnx format, a modern evolution of the traditional .sln.
Based on XML, the .slnx format was adopted for being more human- and tool-readable, reducing complexity for integration with external systems and CI/CD pipelines.

In addition, its cleaner structure significantly improves version control — changes are more predictable and easier to review.
This change aligns with the future direction of the .NET ecosystem, promoting greater interoperability, extensibility, and automation in project development.

The Community subscription now supports project generation based on .NET 9 and Aspire 9.2.1, allowing users to explore the platform's features for free and technically.

This release includes:
_ Creation of services and entities with automated scaffolding;
_ Database selection and full initial configuration;
_ Functional generation up to the EF Core Migrations stage.

Although advanced features like microservices and modular monoliths are restricted to paid plans, this version provides a solid foundation for evaluating the generated architecture, code quality, and integration with the modern .NET ecosystem.

The CLI now offers the command lino database migrations add to simplify creating migrations for any service or module in the project.

This feature automates generating migration scripts tied to the build version and allows consistent documentation of changes.

Key benefits:
_ Fast creation of migrations by service or module with simple and straightforward commands.
_ Automatic generation of .sql scripts compatible with project versioning.
_ Facilitates database version control even in distributed architectures.
_ Standardizes and documents structural database changes in a secure and auditable manner.
_ Natural integration with the application's build and deploy workflow.

The new versioning feature allows you to list existing versions and bump the version of services and web applications generated by the tool, following the SemVer (Semantic Versioning) convention. This ensures better traceability, standardization, and control in the release cycle.

Using the version command, it's easy to set and update the version number of each service or application, streamlining audits and incorporating best practices into the development workflow.

The build command has also been enhanced to generate Docker images already tagged with the defined version, simplifying packaging and preparing applications for deployment.

These improvements increase consistency and predictability in release management, offering greater transparency to development and operations teams.

Customize which properties will be considered when generating Command (Post, Put, Patch) and Query (Get) artifacts.

This feature offers:
_ Interactive CLI interface for selecting properties during the entity scaffolding process;
_ Automatic generation of objects with only the selected fields for input/output;
_ Full support for customizing payloads in REST APIs, increasing flexibility and control over transmitted data;
_ Integration with validation and generated data contracts, respecting rules of requirement and consistency.

This enhancement aims to offer greater granularity in artifact modeling, allowing developers to precisely control what is exposed, persisted, or queried through the architecture generated by the CLI.

An automatic versioning and backup mechanism has been implemented in Lino CLI to ensure security and traceability in file generation and overwriting processes.

All generated files are stored in the /.lino/files/.../received/ folder, ensuring that each file is chronologically organized and easy to locate.

Files that are replaced remain stored in the /.lino/files/.../replaced/ folder, allowing recovery of previous versions when needed. This backup structure provides greater control and security, enabling full auditing of generated files, especially in collaborative and automated development environments.

Complete implementation of authentication and authorization for frontend and backend projects based on JWT (JSON Web Tokens) and granular permission control through custom Authorization Policies in ASP.NET Core.

Highlights:
_ Secure login with issuance and validation of JWTs.
_ Authorization based on custom policies (Claims and Roles).
_ Automatic integration between generated APIs and frontends (Blazor).
_ Protection of routes and components based on user permissions.

Advantages:
_ Robust security for modern applications.
_ Standardization of access model by profile and domain.
_ Secure and integrated experience across application layers.
_ Ease of extension or adaptation according to company scenarios.

It is now possible to add one or more frontends to generated projects, with initial support for Blazor Web Apps — including both Server and WebAssembly models.

These frontends are automatically integrated with the APIs generated by the tool, allowing the creation of complete CRUD pages with direct calls to backend endpoints and database persistence.

Highlights:
_ UI generation based on domain entities.
_ Native communication with the generated APIs.
_ End-to-end functionality: frontend, backend, and database working together.
_ Possibility of multiple frontends in the same project (e.g., admin, portal, public).

Benefits:
_ Agility in interface development.
_ Less rework and manual integration.
_ Unified standard for navigation, style, and data access.
_ Increased productivity with automatic CRUD page generation.

We have implemented the Transactional Outbox pattern to ensure reliability in sending integration events. Instead of publishing the event directly during the application transaction, it is now recorded in a specific table within the same database transaction.

Later, a background job reads this outbox and performs the actual event dispatch.

Benefits of this approach:
_ Ensures consistency between database changes and event publication.
_ Prevents message loss in case of intermediate failures.
_ Allows control over retransmission and auditing of published events.
_ Aligns with best practices of event-driven architecture and microservices.

The option to include Background Jobs in the generated services — whether simple or modular — has been added using the Hangfire library.

As a result, projects now natively support scheduling and executing background tasks, including:
_ Recurring (cron), scheduled, or immediate execution.
_ Monitoring via integrated control panel.
_ Secure persistence and reprocessing of jobs.

This mechanism can also be used alongside the Transactional Outbox Pattern, ensuring reliable delivery of integration events even in partial failures or distributed scenarios.

Key advantages:
_ Automation of recurring and long-running tasks without blocking the main flow.
_ High resilience and persistence of background tasks.
_ Out-of-the-box integration with the Outbox pattern for reliable events.
_ Easy job configuration and customization per service.
_ Embedded dashboard for execution inspection and control.

The option to configure support for asynchronous messaging with RabbitMQ has been added, using the abstraction and advanced features of MassTransit.

As a result, the generated services can communicate in a decoupled and resilient manner, using distributed events and commands.

Integration highlights:
_ Automated transport configuration with RabbitMQ.
_ Publishing and listening to events via MassTransit with native dependency injection.
_ Compatible with the Transactional Outbox pattern for greater reliability.

Advantages:
_ High scalability with event-based communication.
_ Decoupling between producers and consumers.
_ Greater fault tolerance and automatic reprocessing.
_ Ease of maintenance and extension of asynchronous business flows.

A robust Unit of Work mechanism has been implemented, providing full transaction control, domain event management, integration event publishing (Outbox Pattern), automatic rollback, and support for the Result pattern to commit or rollback based on operation success or failure.

Highlights:
_ Explicit transaction creation with isolation level control.
_ Domain Events published in sync with data persistence.
_ Integration Events published decoupled via Outbox Pattern.
_ Automatic rollback and exception handling with constraint validation support.
_ Commit conditioned on the operation Result.
_ Structured logging of events, transactions, and failures.

Benefits:
_ Transactional consistency between database writes and generated events.
_ Flexibility to use standard SaveChanges or full control of the flow.
_ Easy unit testing and error traceability.
_ Clear separation between Domain and Infrastructure, with MediatR support.

It is now possible to define, individually for each generated service, the database to be used — with native support for SQL Server and PostgreSQL.

This approach allows each service to have its own dedicated database, ensuring full isolation and facilitating architectural practices aligned with real microservices.

In the case of modular services, the application still uses a single database per service, with each module separated by schema, maintaining organization and cohesion.

Key benefits:
_ Data isolation between services, improving security and responsibility clarity.
_ Enables progressive adoption of microservices with independent databases.
_ Schema-based separation in modular services, making maintenance and domain understanding easier.
_ Full flexibility in choosing the most suitable DBMS for each service.
_ Easier testing, isolated deployments, and horizontal scalability.

The Lino CLI now allows the developer to choose, during project generation, between creating simple services (traditional) or modular services, with full freedom to mix both as needed by the solution.

This approach directly supports different architectural styles:
Simple services: ideal for building microservice-based solutions or for constructing traditional monolithic applications in a straightforward and isolated way.
Modular services: organize the application’s domain into Bounded Contexts, enabling the adoption of a Modular Monolith with clear separation of responsibilities and better cohesion among components.

You can add as many services as you like — simple, modular, or both — depending on the application scenario.

Advantages of this approach:
_ Greater flexibility in architectural modeling.
_ Easier progressive scaling from monolith to microservices.
_ Clear separation of responsibilities by domain or context.
_ Better code organization and alignment with modern architecture best practices.
_ Reduction of coupling and increased maintainability.

Develop with microservices or adopt a modular monolith — you choose the ideal path for your application.

Native support for hybrid caching has been added using the Microsoft.Extensions.Caching.Hybrid library.

The implementation combines in-memory caching (MemoryCache) with distributed caching (DistributedCache), offering the best of both worlds.

This approach enables extremely fast responses to frequent requests while maintaining synchronization and scalability in distributed environments.

Benefits of the hybrid strategy:
_ High performance with immediate reads from local memory.
_ Data persistence and sharing between instances via distributed cache.
_ Reduced calls to the database and external APIs.
_ Better horizontal scalability in applications with multiple replicas.
_ Smart synchronization between the two cache layers.

Ideal for scenarios requiring performance and consistency without sacrificing architectural flexibility.

Lino CLI now generates projects with built-in support for multiple languages, including automatic translation for the following cultures:
en, pt-BR, es, fr, it, de, ja, ko, zh-Hans, and ru.

Resource files (resx) are automatically generated based on the main language, and contents are automatically translated, ready for immediate use in global applications.

Advantages of multilingual support:
_ Facilitates the creation of applications targeting different regions and cultures.
_ Reduces the time required for internationalization.
_ Native integration with the .NET localization system.
_ Improves the end-user experience in multilingual applications.
_ Enables rapid scaling of solutions for the global market.

The codes generated by Lino CLI now use LoggerMessage to log more efficiently and with better performance.

Unlike conventional extension methods of ILogger that generate boxing of value types and impact runtime allocation, the LoggerMessage pattern creates strongly typed, static Actions for each log message.

Advantages of this approach:
_ Significant reduction in memory allocations.
_ Avoids boxing of value types such as int, Guid, DateTime, etc.
_ Better performance in high-volume logging scenarios.
_ Standardization and centralization of log messages.
_ More clarity in auditing, diagnostics, and monitoring.

This improvement is especially relevant in APIs and backend services where performance and traceability are critical.

Lino CLI now offers optional support for Strongly Typed Ids, allowing entity identifiers to be represented by strongly typed specific types instead of generic types like Guid or int.

This feature helps prevent common mistakes such as assigning an identifier from one entity to another incorrectly, and also makes the code more expressive and aligned with the application's domain.

Advantages of using Strongly Typed Ids:
_ Greater type safety at compile time.
_ Prevents accidental assignments between different entities.
_ Improves code readability and clarity of intent.
_ Eases tracking and debugging of identifiers in the domain.
_ Integration with EF Core, JSON serialization, and validation.

This feature is optional and can be enabled during project generation.

Generated projects can now be configured with support for static code analysis, using the main analyzers from the .NET ecosystem. These tools are integrated directly into the build and help identify formatting, style, architecture issues, and possible logic errors early in development.

Advantages:
_ Promotes consistency and standardization in code from the start.
_ Detects bugs and bad practices early.
_ Facilitates code reviews and technical onboarding.
_ Improves codebase quality and maintainability.
_ Prevents common errors and improves adherence to .NET best practices.

The configuration can be customized per project, allowing greater flexibility in the desired level of rigor.

Creation of the Tolitech.Results library, which fully and fluently implements the Result Pattern in .NET.

This library encapsulates the result of operations — whether successful or failed — into structured objects containing HTTP status, messages, errors, titles, details, and optional data (with support for Result<T>).

Benefits of using the Result Pattern:
_ Standardization of operation returns across the application.
_ Reduction of exceptions as flow control.
_ Ease of composing and chaining operations.
_ Better support for communication between layers and services.
_ Smooth integration with HTTP APIs, validations, and error messages.
_ Improved debugging experience and structured logging.

Additionally, extensions like Tolitech.Results.Http and Tolitech.Results.Guards expand integration with REST APIs and defensive validations.