likec4/likec4

Features

• System Architecture Models - Provides a domain-specific language to define custom architectural models with nested levels and tailored notations.
• Diagram as Code Frameworks - Provides a framework for defining software architecture and system models using a version-controlled, text-based language.
• Documentation-as-Code Systems - Provides a framework for defining system architecture as code within version-controlled repositories.
• Graph Relationship Modeling - Maintains the system architecture as a resource graph of components and dependencies for hierarchy analysis.
• System Architecture Visualizers - Transforms architectural models into interactive visual maps of software structures and interaction logic.
• Architecture Visualizers - Transforms architectural code into interactive visual representations that can be explored at multiple levels of detail.
• Interactive Diagramming Libraries - Ships a framework for embedding interactive, browser-rendered architecture diagrams into external applications.
• Domain Specific Language Parsers - Translates text-based architecture definitions into a structured, traversable data model of elements and relationships.
• Architectural Documentation - Provides interactive, navigable technical overviews of system design and component hierarchies.
• Architectural Relationship Models - Maps associations and dependencies between system entities to analyze architectural hierarchies and relationship chains.
• Architecture Element Referencing - Links components using unique identifiers or paths to resolve ambiguity between architectural elements.
• Architecture Model Parsing - Processes architecture descriptions from files or strings to create a traversable data model.
• Hierarchy Definitions - Organizes architectural elements into nested structures to represent relationships between high-level systems and internal components.
• Logical Element Definitions - Allows the creation of logical building blocks to represent the structural components of a software system.
• Declarative View Projections - Generates dynamic architectural diagrams by applying scoping and filtering rules to a global system model.
• Deployment Infrastructure Modeling - Provides the ability to create physical models of deployment nodes to represent target environments and their properties.
• Deployment Model Visualization - Renders diagrams based on deployment models, applying filters to organize visible infrastructure elements.
• Element Relationship Mapping - Allows mapping connections between architecture elements to describe how different software components interact.
• Infrastructure Relationship Modeling - Establishes physical connections between deployed instances to represent network and hardware dependencies.
• Logical to Infrastructure Mapping - Maps logical software components to physical deployment nodes to visualize architectural distribution.
• Scoped Views - Limits diagrams to a specific element and its descendants to focus on a particular subsystem.
• C4 Architecture Diagrams - Generates visual projections based on the C4 model to illustrate system overviews and data flows.
• Architecture Visualizers - Generates visual diagrams and topology maps based on defined architectural models to visualize system structure.
• Text-to-Diagram Generators - Integrates with CI/CD pipelines to automatically transform architecture definitions into static sites or image exports.
• Container Nesting - Organizes components as nested containers to represent complex system hierarchies and namespaces.
• Interactive Architecture Navigation - Offers an interactive interface to explore diagrams and drill down into specific architectural components.
• Interactive Diagram Embedding - Enables rendering interactive architectural views within web applications using dedicated components and popup browsers.
• Model Domain Splitting - Enables dividing large architectural models into smaller, domain-based projects to improve organization and maintainability.
• Modeling Intelligence - Provides syntax highlighting, live previews, and real-time error reporting within code editors to streamline the architectural modeling process.
• LSP-Integrated Environments - Integrates a Language Server to provide real-time validation and autocomplete for architecture modeling within editors.
• Website Builders - Generates a standalone website or single HTML file containing all architectural diagrams for easy hosting and sharing.
• Static Websites - Generates static HTML files and assets from architecture definitions for hosting.
• Relationship Edge Styling - Allows defining colors and arrow types for connections to visually distinguish between different types of system interactions.
• Architecture Element Styling - Enables setting custom colors, shapes, and icons for architectural elements both globally and on an individual basis.
• Code Navigators - Implements project-wide navigation for jumping to definitions, finding references, and renaming elements within the architecture model.
• Diagramming Integrations - Provides plugins and web components to integrate interactive architectural views into websites and documentation.
• Label-Based Categorization - Assigns labels to architectural elements to group and filter components based on semantic metadata.
• Language Server Protocol Implementations - Implements the Language Server Protocol to provide real-time validation, autocomplete, and navigation for the modeling language.
• Language Servers - Exposes a standalone language server that provides autocomplete, diagnostics, and navigation to any LSP-compliant editor.
• Live Preview Servers - Hosts a local server that provides real-time visual rendering of diagrams as source files are edited.
• Programmatic Architecture Construction - Enables the creation of architectural models using a type-safe builder to ensure structural consistency through code.
• Project Configuration - Allows defining project settings and visual styles using type-safe code files instead of static configuration formats.
• Drift Detection - Identifies structural discrepancies and undeclared dependencies between the architectural model and actual code.
• Architecture Model Querying - Enables traversal of elements and metadata within a model to retrieve structural and deployment data.
• React Component Generators - Generates React components that render architecture model views for integration into web applications.
• Cross-Project Element Referencing - Enables referencing elements defined in separate projects to reuse architectural components without duplicating definitions.
• Deployment Model Visualizations - Maps logical software components to physical infrastructure nodes to visualize system distribution.
• Diagram Layout Organizers - Provides auto-layout configuration to automatically organize the arrangement and directional flow of nodes in diagrams.
• Element Interaction Mapping - Enables the definition of interactions and data flows between different components of a software system.
• External Model Inclusions - Supports loading architecture specifications from external locations to share common elements across different projects.
• Implicit View Generation - Automatically generates scoped views for elements to enable seamless drill-down navigation through the architecture.
• Deployment Workflows - Automates the deployment of architecture diagrams to static sites using CI/CD workflows.
• Interaction Sequence Visualization - Renders interaction scenarios as sequence charts to visualize the order of actor interactions.
• Metadata-Based Element Filtering - Enables precise isolation of system components using metadata tags and boolean logic for focused architectural views.
• Model Definition Modularization - Allows distributing architecture definitions across multiple files that are merged into a single model during parsing.
• External Component Definitions - Allows defining internal components in separate files to keep top-level architectural views clean and manageable.
• Shared Configuration Files - Allows including a single source specification file across multiple projects to maintain consistent architectural definitions.
• Live Preview Servers - Ships a local preview server that provides real-time, hot-reloading updates for architecture diagrams as source files are edited.
• Use Case Modeling - Provides tools and notations for defining system actors and use case scenarios without altering the global model.
• Architectural Design Validations - Checks for drift and breaking changes to ensure the software implementation matches the architectural design.
• Model Structural Validation - Checks source files for syntax errors and outdated manual layouts to ensure the architectural model remains structurally correct.
• Constraint Layout Engines - Implements a constraint-based layout engine to automatically organize node positions and axis alignments in diagrams.
• Custom Element Renderers - Allows replacing default node visualizations with custom components to tailor how architectural elements are presented.
• Element Groupings - Wraps architectural elements within rendered boundaries to visually represent logical groupings and namespaces.
• Icon Set Integrations - Supports embedding external image formats or selecting from icon sets to visually represent specific system components.
• Shared Style Modules - Allows importing reusable style definitions from external configuration files to maintain visual consistency across different repositories.
• Visual Style Customization - Allows the definition of custom colors and themes to apply branding to architecture views.
• Diagram Element Styling - Defines the appearance of elements using a sequence of overriding rules for colors and line styles.
• Theme Customization - Provides capabilities to override default colors and sizes using CSS or configuration objects to customize the global appearance.
• Diagram Web Components - Creates a JavaScript bundle that embeds diagrams as a customizable and reusable HTML element.
• Headless Rendering Engines - Uses a headless browser rendering engine to rasterize dynamic web diagrams into static image files like PNG.
• Live Component Embedding - Allows live architecture diagrams to be integrated directly into web applications with instant updates via hot module replacement.
• Multi-Target Component Generation - Produces diverse output formats including React components, web components, and static HTML from architectural definitions.

Star history