BranchesTags

Repository files navigation

KAS GUI

Test StatusCrates.iokas-textDocs

Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design

About Kas

The Kas GUI system strives to be both fast and follow Alan Kay's slogan:

Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs: 
let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello

An excerpt from examples/counter.rs:

#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}

Counter

On the more complex end, custom widgets can be fairly complex; check the Kas widget library (including source code) for examples.

Capabilities

  • Fully keyboard-accessible
  • Screen reader support (partial: #509)
  • IME support (partial: #508)
  • Integrated i18n support (not yet started; #7)
  • Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  • Automatic margins and layout with pixel-perfect scaling
  • Support for custom themes including theme-driven animations and sizing
  • Virtual scrolling (list or grid), including support for async data access

Goals

Kas is designed to:

  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries

Limitations

Every approach has its limitations. Ours are:

  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).

Status

In development. Interfaces are not currently stable.

Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.

Crates and features

Crates in this repository:

  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above

Significant external dependencies:

  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected

Feature flags

The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default. See documentation in Cargo.toml.

Copyright and Licence

The COPYRIGHT file includes a list of contributors who claim copyright on this project. This list may be incomplete; new contributors may optionally add themselves to this list.

The KAS library is published under the terms of the Apache License, Version 2.0. You may obtain a copy of this licence from the LICENSE file or on the following webpage: https://www.apache.org/licenses/LICENSE-2.0

About

Another GUI toolkit

Resources

Readme
Apache-2.0 license

Contributing

Contributing
Activity
Custom properties

Stars

1.0k stars

Watchers

16 watching

Forks

31 forks
Report repository

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
KAS GUI
Test StatusCrates.iokas-textDocs
Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design
About Kas
The Kas GUI system strives to be both fast and follow Alan Kay's slogan:
Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column!["Hello, world!",Button::label("&Close").with(|cx, _| cx.exit())];
Hello
An excerpt from examples/counter.rs:
#[derive(Clone,Debug)]structIncrement(i32);fncounter() -> implWidget{let tree = column![
format_label!("{}").align(AlignHints::CENTER),
row![Button::label_msg("−",Increment(-1)),Button::label_msg("+",Increment(1)),].map_any(),];
tree.with_state(0).on_message(|_, count,Increment(add)| *count += add)}
Counter
On the more complex end, custom widgets can be fairly complex; check the Kas
widget library (including source code) for examples.
Capabilities
  •  Fully keyboard-accessible
  •  Screen reader support (partial: #509)
  •  IME support (partial: #508)
  •  Integrated i18n support (not yet started; #7)
  •  Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
  •  Automatic margins and layout with pixel-perfect scaling
  •  Support for custom themes including theme-driven animations and sizing
  •  Virtual scrolling (list or grid), including support for async data access
Goals
Kas is designed to:
  • Support stateful user-defined widgets with high-ish level of code
  • Support the best user-interaction possible
  • Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
  • Support extremely fast, monolithic Rust binaries
Limitations
Every approach has its limitations. Ours are:
  • Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
  • Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
  • Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).
Status
In development. Interfaces are not currently stable.
Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.
Crates and features
Crates in this repository:
  • kas-core: the core library
  • kas-macros: proc-macro crate (see kas-core documentation)
  • kas-widgets: the main widget library
  • kas-view: view widgets supporting virtual scrolling
  • kas-image: scalable and raster image widgets and utilities
  • kas-wgpu: rendering backend over wgpu
  • kas-soft: basic CPU rendering backend over softbuffer
  • kas-dylib: helper crate to support dynamic linking
  • kas: a meta-package plus convenient driver covering most of the above
Significant external dependencies:
  • winit: platform window integration
  • wgpu: modern accelerated graphics API
  • AccessKit: Accessibility infrastructure for UI toolkits
  • kas-text: complex text support
  • rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
  • fontique: Font enumeration and fallback
  • resvg: an SVG rendering library
  • tiny-skia: a tiny Skia subset ported to Rust
  • Image: An Image Processing Library
  • impl-tools: autoimpl and impl_scope (extensible) macros
  • easy-cast: Type conversion, success expected
Feature flags
The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default.
See documentation in Cargo.toml.
Copyright and Licence
The COPYRIGHT file includes a list of contributors who claim
copyright on this project. This list may be incomplete; new contributors may
optionally add themselves to this list.
The KAS library is published under the terms of the Apache License, Version 2.0.
You may obtain a copy of this licence from the LICENSE file or on
the following webpage: https://www.apache.org/licenses/LICENSE-2.0
About
Another GUI toolkit
Resources
Readme
Apache-2.0 license
Contributing
Contributing
Activity
Custom properties
Stars
1.0k stars
Watchers
16 watching
Forks
31 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages