# slint-ui/slint

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/slint-ui-slint).**

21,785 stars · 819 forks · Rust · other

## Links

- GitHub: https://github.com/slint-ui/slint
- Homepage: https://slint.dev
- awesome-repositories: https://awesome-repositories.com/repository/slint-ui-slint.md

## Topics

`cpp` `declarative-ui` `desktop` `embedded-devices` `gui` `javascript` `language` `lsp-server` `native` `rust` `rust-lang` `toolkit` `ui` `user-interface` `wasm` `webassembly` `widgets`

## Description

Slint is a declarative user interface framework designed for building native graphical applications across desktop, mobile, and embedded platforms. It utilizes a specialized markup language to define reactive interface components, which are then compiled into optimized machine code to ensure high performance and minimal resource consumption. By separating visual structure from application logic, the framework enables developers to create consistent interfaces that run efficiently on hardware ranging from resource-constrained microcontrollers to high-end desktop systems.

The framework distinguishes itself through a focus on native performance and hardware-level flexibility. It provides a platform abstraction layer that supports direct hardware rendering and configurable windowing backends, allowing applications to bypass heavy dependencies where necessary. Developers can integrate these interfaces with backend business logic written in languages like C++ or Rust through a standardized language-agnostic bridge, ensuring that the UI remains responsive while maintaining deep connectivity with native application code.

The development experience is supported by a suite of tooling that includes real-time previewing, design token translation, and integrated diagnostics via the Language Server Protocol. The framework also incorporates comprehensive state management, including reactive property binding and bidirectional synchronization, to handle complex data flows. These capabilities are complemented by built-in support for accessibility, localization, and responsive layout management, providing a complete environment for constructing modular and maintainable graphical interfaces.

## Tags

### User Interface & Experience

- [Cross-Platform UI Toolkits](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-toolkits.md) — Enables consistent native graphical interface development across desktop, mobile, and embedded platforms.
- [Declarative UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/rendering-models/declarative-frameworks/declarative-ui-frameworks.md) — Defines complex, reactive user interface components using a specialized markup language that separates visual structure from application logic.
- [Cross-Platform UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-frameworks.md) — Creates consistent graphical applications that run natively across desktop, mobile, and embedded platforms from a single codebase.
- [Embedded User Interfaces](https://awesome-repositories.com/f/user-interface-experience/embedded-user-interfaces.md) — Builds high-performance, resource-efficient user interfaces for embedded Linux and microcontroller hardware using declarative markup and native rendering.
- [GUI Toolkits](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/gui-toolkits.md) — Provides a lightweight rendering engine optimized for resource-constrained embedded hardware.
- [Custom Component Builders](https://awesome-repositories.com/f/user-interface-experience/custom-component-extensions/custom-component-builders.md) — Provides builders for creating reusable custom interface elements with integrated state and layout logic. ([source](https://docs.slint.dev/latest/docs/slint/guide/development/custom-controls/))
- [Declarative Component Architectures](https://awesome-repositories.com/f/user-interface-experience/declarative-component-architectures.md) — Structures user interfaces as a hierarchy of reusable components defined through a specialized markup language.
- [Reactive Property Bindings](https://awesome-repositories.com/f/user-interface-experience/reactive-property-bindings.md) — Automatically updates the user interface by linking properties to reactive expressions. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/concepts/reactivity/))
- [Constraint Based Layouts](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/css-layout-systems/constraint-based-layouts.md) — Organizes components using constraint-based layout engines that dynamically calculate positions and sizes. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/coding/positioning-and-layouts/))
- [Responsive Layout Adapters](https://awesome-repositories.com/f/user-interface-experience/responsive-layout-adapters.md) — Adapts component visibility and arrangement dynamically based on container dimensions for responsive design. ([source](https://docs.slint.dev/latest/docs/slint/guide/development/custom-controls/))
- [Repeated Layout Schemas](https://awesome-repositories.com/f/user-interface-experience/schema-rendering/repeated-layout-schemas.md) — Generates repeated interface elements by iterating through data models and applying consistent layout schemas. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/coding/repetition-and-data-models/))
- [Accessible UI Components](https://awesome-repositories.com/f/user-interface-experience/accessible-ui-components.md) — Supports accessibility standards by attaching labels, roles, and actions to custom interface components. ([source](https://docs.slint.dev/latest/docs/slint/guide/development/best-practices/))
- [Event Handling](https://awesome-repositories.com/f/user-interface-experience/event-handling.md) — Manages callbacks for user interactions and system events to signal state changes. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/coding/functions-and-callbacks/))
- [Focus Management](https://awesome-repositories.com/f/user-interface-experience/focus-management.md) — Provides programmatic control over input focus and interaction states for interface elements. ([source](https://docs.slint.dev/latest/docs/slint/guide/development/focus/))
- [Interface Localization](https://awesome-repositories.com/f/user-interface-experience/interface-localization.md) — Supports multi-language interfaces by managing string extraction and runtime loading for translation. ([source](https://docs.slint.dev/latest/docs/slint/guide/development/best-practices/))
- [State Reconciliation Strategies](https://awesome-repositories.com/f/user-interface-experience/state-reconciliation-strategies.md) — Updates only the specific interface elements affected by state changes to maintain high performance without full re-renders.

### Software Engineering & Architecture

- [Application Logic Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/application-logic-frameworks.md) — Integrates declarative UI components with backend business logic written in languages like C++ or Rust.
- [Compile-Time Code Generation](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation.md) — Transforms declarative interface markup into highly optimized native machine code to minimize runtime memory and CPU overhead.
- [Platform Abstraction Layers](https://awesome-repositories.com/f/software-engineering-architecture/platform-abstraction-layers.md) — Decouples the rendering and input logic from specific hardware or operating systems to enable cross-platform deployment.
- [State Containers](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/centralized-state-containers/state-containers.md) — Maintains a shared singleton object for consistent global state access across components. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/coding/globals/))
- [Language-Agnostic Logic Models](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/language-agnostic-logic-models.md) — Exposes interface properties and callbacks to host applications through a standardized foreign function interface for multi-language support.

### Graphics & Multimedia

- [Real-time Media Previews](https://awesome-repositories.com/f/graphics-multimedia/media-processing-analysis/real-time-media-previews.md) — Provides real-time visual previews and instant feedback during the interface design process.
- [Graphics Rendering APIs](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/graphics-apis-bindings/graphics-rendering-apis.md) — Draws graphical elements directly to screen buffers or graphics APIs without requiring heavy windowing system dependencies.
- [State Transition Animators](https://awesome-repositories.com/f/graphics-multimedia/media-production-suites/animation-tools/programmatic-animation-apis/state-transition-animators.md) — Implements state-based animation engines that tween property values for smooth visual transitions. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/coding/animation/))

### Development Tools & Productivity

- [Language Servers](https://awesome-repositories.com/f/development-tools-productivity/language-servers.md) — Implements the Language Server Protocol to provide real-time diagnostics and code intelligence in standard editors.
- [Live Preview Tools](https://awesome-repositories.com/f/development-tools-productivity/live-preview-tools.md) — Renders user interface changes in real-time during development to allow for rapid iteration without requiring a full project recompilation. ([source](https://docs.slint.dev/latest/docs/slint/guide/tooling/manual-setup/))

### Web Development

- [Bidirectional Bindings](https://awesome-repositories.com/f/web-development/frontend-development-tools/frontend-frameworks/directives/property-bindings/bidirectional-bindings.md) — Links properties together so that changes are automatically reflected in both directions. ([source](https://docs.slint.dev/latest/docs/slint/guide/language/concepts/reactivity/))