Skip to main content
Visual Modelers in Intent Architect provide graphical design surfaces for modeling different aspects of your application. These designers enable you to visually express complex application structures, which Intent Architect then uses to generate production-ready code.

​
What are Visual Modelers?

Visual Modelers are specialized design environments that allow you to create visual representations of your application’s architecture, business logic, and user interfaces. Each modeler focuses on a specific domain and provides appropriate visual elements and relationships to model that domain effectively.

​
Available Modelers

Intent Architect provides several core visual modelers:

Domain Modeler

Model your application’s domain entities, value objects, and aggregates using UML-style class diagrams.

Services Modeler

Design service operations, commands, queries, and DTOs for your application’s service layer.

UI Modeler

Create user interface components, pages, and navigation structures visually.

Eventing Modeler

Model message-based integration, events, and event handlers for distributed systems.

​
Key Benefits

​
Visual Clarity

Visual models provide an intuitive, graphical representation of complex systems that is easier to understand and communicate than code alone.

​
Technology Agnostic

Models focus on the “what” rather than the “how,” allowing you to change implementation technologies without redesigning your architecture.

​
Code Generation

Intent Architect uses your visual models as the single source of truth to generate consistent, high-quality code across your entire application.

​
Team Collaboration

Visual models serve as a common language between developers, architects, and stakeholders, facilitating better communication and understanding.

​
How Modelers Work

​
Designer Configuration

Each modeler is configured through a .designer.config file that defines:
  • Designer ID: Unique identifier for the designer
  • Designer Name: Display name in the Intent Architect interface
  • Order: Determines the ordering of designers in the UI
  • Icon: Visual icon representing the designer
  • Designer References: References to type systems and other designers
  • Package References: Metadata packages that extend the designer’s capabilities

​
Element Types

Modelers provide specific element types that you can add to diagrams:
  • Classes/Entities: Represent domain objects or DTOs
  • Operations: Define methods and service operations
  • Associations: Express relationships between elements
  • Folders: Organize elements hierarchically
  • Diagrams: Visual canvases for arranging elements

​
Metadata API

Templates and modules access modeler data through strongly-typed metadata APIs: 
var entities = model.GetDomainPackageModel()?.Classes;
foreach (var entity in entities)
{
    var attributes = entity.Attributes;
    var associations = entity.AssociatedClasses;
    // Generate code based on model structure
}

​
Designer Integration

Visual modelers integrate seamlessly with Intent Architect’s module system:
  • Templates read model data to generate code
  • Decorators can modify or enhance generated output
  • Stereotypes add metadata to model elements
  • Settings customize naming conventions and behaviors

​
Getting Started

To work with visual modelers:
  1. Create a Package: In your designer, create a new package to contain your models
  2. Add Elements: Use the context menu or toolbox to add elements to diagrams
  3. Configure Properties: Set names, types, and stereotypes on your elements
  4. Create Relationships: Draw associations between related elements
  5. Run the Software Factory: Generate code from your visual models

​
Learn More

Explore each modeler in detail:

Build docs developers (and LLMs) love

Get started for freeTalk to us