emilk/egui

This system is a Rust-based immediate-mode GUI framework designed for building cross-platform desktop and web applications. It provides a comprehensive toolkit for rendering UI elements, handling user input, and managing window lifecycles across native operating systems and browsers. The framework supports multiple rendering backends, including OpenGL and WGPU, and includes utilities for image loading, text layout, and accessibility inspection.

36 changes.

The project reorganized its codebase into a modular crate structure, introducing dedicated libraries for color, math, and rendering backends while removing legacy GUI entry points. This period focused on establishing a robust cross-platform foundation through the eframe crate and significantly expanding the example suite to demonstrate advanced features like 3D rendering, profiling, and custom window frames.

23 changes.

This period focused on enhancing developer tooling through the introduction of the xtask crate, comprehensive CI scripts, and the new egui\_kittest harness for UI testing. It also expanded platform support with Android examples and improved image loading infrastructure, while adding numerous examples to demonstrate advanced features like multi-threading, viewports, and custom input handling.

11 changes.

This period focused on introducing the egui\_inspection crate to enable external tooling for inspecting and controlling running applications, alongside significant expansion of snapshot and regression test coverage across the library. Development also included refactoring shape definitions, adding new drawing primitives like BandShape, and creating examples for external event loops, SVG glyphs, and live styling customization.

A new example project has been added to demonstrate running egui applications on Android. The \hello\_android\ crate includes a \lib.rs\ entry point that initializes the Android environment, configures \eframe::NativeOptions\ with the Android app context, and runs the native UI loop. It leverages \egui\_demo\_lib\ to display demo windows and includes a specific workaround to reserve space for the Android status bar. A corresponding \main.rs\ is provided for desktop testing, and a README details the prerequisites for building and running the app on Android devices.

_examples/hello\android · high confidence

The custom\_style example now demonstrates how to apply distinct visual accents for light and dark themes. Users can switch between system themes to see the light mode use a green accent and the dark mode use a purple accent, applied via the new \style\_mut\_of\ API.

_examples/custom\style · high confidence

The \custom\_window\_frame\ example demonstrates how to hide the default OS window chrome and draw a custom title bar and window frame using egui. It shows how to configure the viewport for transparency and rounded corners, handle window dragging and maximization via viewport commands, and on macOS, integrate native traffic-light buttons into the custom title bar.

(repo-wide) · high confidence

A new example demonstrating how to embed 3D rendering using the \glow\ (OpenGL) library within \eframe\ has been added. This advanced usage guide shows how to integrate a custom rotating triangle via \egui::PaintCallback\, allowing users to drag and rotate the 3D object while egui sits on top. The example includes a README with usage instructions and a screenshot.

_examples/custom\_3d\glow · high confidence

The \egui\_demo\_lib\ crate is introduced to provide demo code for testing third-party egui integrations, benchmarks, and tests. It includes a \ColorTest\ (rendering test) that helps users diagnose rendering backend issues by verifying sRGB-aware texture sampling, gamma-space color operations, and correct blending. The library also exposes utility functions like \rust\_view\_ui\ for syntax-highlighted code viewing, helpers for generating GitHub source links, and a mobile detection function.

_crates/egui\_demo\lib/src · high confidence

A new example application demonstrates how to request user attention (informational or critical) and reset it after a timeout. Users can select the attention type via a combo box, trigger a request that highlights the window after a short delay, and optionally enable an automatic reset after three seconds. This feature is native-only and requires unfocusing the window to observe the visual effect.

_examples/user\attention · high confidence

A new hello\_world example has been added to the examples directory, providing a runnable reference application that showcases fundamental UI controls such as labels, text input, sliders, and buttons. The example initializes the application using eframe::NativeOptions with a custom viewport size, sets up image loading support, and implements a simple app state that updates a greeting message based on user input. It also includes a README with run instructions and a screenshot for documentation purposes.

_examples/hello\world · high confidence

A new example project has been added to showcase basic UI controls (Label, TextEdit, Slider, Button) using the simplified native-only eframe API. The example demonstrates the updated \eframe::run\_ui\_native\ entry point, \eframe::Result\ shorthand, \ViewportBuilder\ for window sizing, and \env\_logger\ for logging.

_examples/hello\_world\simple · high confidence

The \examples/multiple\_viewports\ directory now contains a runnable example showing how to create and manage multiple native windows (viewports) using \eframe\. The example demonstrates creating an immediate child viewport that repaints with the parent and a deferred child viewport that runs independently, including how to handle viewport closing requests and embed viewports within the main window.

_examples/multiple\viewports · high confidence

A new example at examples/hello\_world\_par demonstrates using egui in parallel from multiple threads. The application spawns background worker threads that each maintain their own UI state (name, age) and render individual windows by receiving egui Context handles via channels, while the main thread manages thread lifecycle and spawns additional workers on demand.

_examples/hello\_world\par · high confidence

The examples/popups directory now includes a runnable example (cargo run -p popups) that demonstrates the PopupCloseBehavior API. The example showcases three distinct behaviors: CloseOnClick (default ComboBox behavior), CloseOnClickOutside (ComboBox that stays open when clicking checkboxes inside), and IgnoreClicks (Popup menu that only closes when the triggering button is pressed again). This provides users with a concrete reference for controlling popup dismissal interactions.

examples/popups · high confidence

A new example application demonstrates how to integrate the Puffin profiler with an eframe-based app. The example starts a local HTTP server on port 8585 to stream profiling data, allowing users to connect via the \puffin\_viewer\ tool. It includes UI controls to toggle continuous repainting and spawn immediate/deferred child viewports, with specific code scopes profiled to help users visualize performance metrics in the profiler.

_examples/puffin\profiler · high confidence

A new example file \pure\_glow.rs\ has been added to demonstrate how to use \egui\_glow\ with a minimal, custom window context implementation using \glutin\ and \winit\, rather than relying on the higher-level \eframe\ crate.

_crates/egui\glow/examples · high confidence

The \egui\_demo\_lib\ now includes a new benchmark suite (\benches/benchmark.rs\) to measure performance across various UI components and rendering operations. This suite uses the \criterion\ crate and the \mimalloc\ allocator to provide accurate timing data. It covers end-to-end demo window rendering (with and without tessellation), specific widget performance (labels, buttons with text and images, and italic text), low-level painter operations (drawing rectangles with strokes), and text layout performance (comparing cached vs. uncached text layout for long strings).

_crates/egui\_demo\lib/benches · high confidence

The \examples/custom\_font\ directory now includes a runnable example demonstrating how to integrate custom fonts into an egui application. The example showcases two approaches: adding a font to the existing set via \Context::add\_font\ and replacing the entire font configuration using \FontDefinitions\. It relies on the \epaint\_default\_fonts\ crate for the source TTF file and utilizes the updated \eframe::Result\ and \ViewportBuilder\ APIs.

_examples/confirm\_exit, examples/custom\font · high confidence

A new Python script (\scripts/generate\_changelog.py\) has been added to automatically summarize recent pull requests and generate changelog entries. The script uses the GitHub CLI to fetch PR details, categorizes them into sections (Added, Changed, Removed, Fixed, Performance) based on labels and titles, and outputs formatted Markdown suitable for inclusion in \CHANGELOG.md\ files.

python · high confidence

The default typefaces (Hack, Ubuntu, Noto Emoji, and egui-icons) are now embedded as static byte arrays within the new \epaint\_default\_fonts\ crate, making them available to \epaint\ without requiring external font files. This change ensures that code rendering, special platform logos (Android, Windows, Apple, GitHub, Git), and optional monochrome emoji are consistently supported out-of-the-box, with the latter two gated behind the \monochrome\_emoji\_fonts\ feature flag.

_crates/epaint\_default\fonts/fonts · high confidence

The DatePickerButton widget now supports configuring the year selection range via \start\_end\_years\, reversing the year dropdown order with \reverse\_years\, and setting the initial scroll position with \year\_scroll\_to\. These builder methods allow users to restrict the selectable years, change the sort order, and ensure the dropdown opens focused on the current selection, improving usability for specific date ranges.

_crates/egui\extras/src/datepicker · high confidence

The \epaint\ crate now exposes \hash\ and \hash\_with\ utility functions in its \util\ module. The \hash\ function provides deterministic hashing by using a fixed-seed \RandomState\ from the \ahash\ library, ensuring consistent results across runs, while \hash\_with\ allows hashing with a custom hasher instance.

crates/epaint/src/util · high confidence

The \egui\ crate now includes a new \atomics\ module providing low-level UI building blocks (\Atom\, \WidgetAtom\, \ContainerAtom\) and a builder trait (\AtomExt\). This allows developers to compose widgets and layouts using a structured, composable API with explicit sizing, alignment, and growth hints, rather than relying solely on the traditional cursor-based layout system.

crates/egui · high confidence

The EasyMark demo library now includes a new editor component that supports keyboard shortcuts for formatting text (bold, code, italics, subscript, superscript, strikethrough, underline, and indent) and provides syntax highlighting for the EasyMark markup language in the editor view.

_crates/egui\_demo\_lib/src/easy\mark · high confidence

The new ecolor crate provides core color types and conversions for the ecosystem. It introduces Color32, a compact 32-bit sRGBA color with premultiplied alpha, and Rgba, a linear-space RGBA type for accurate color manipulation. Support for HSV and HsvaGamma color spaces is included for user-friendly color selection. The crate also adds runtime and compile-time hex string parsing (via the color-hex feature) and implements interoperability with the cint library for external graphics backends.

crates/ecolor/src · high confidence

The new \egui\_glow\ crate provides an OpenGL rendering backend for egui using the \glow\ library. It includes a \Painter\ for managing textures and drawing primitives, automatic shader version detection for compatibility with OpenGL ES and WebGL, and a \winit\ integration (\EguiGlow\) to connect the rendering pipeline with window events. This enables users to run egui applications on platforms that support OpenGL but not wgpu.

_crates/egui\glow/src · high confidence

Added the \egui\_inspection\ crate, which provides a request/response protocol and an \InspectionPlugin\ for \egui\. This enables external tools to inspect a running application by reading the AccessKit tree, injecting input events, resizing viewports, and capturing screenshots (with optional downscaling). The plugin handles requests even when the application window is hidden or minimized by explicitly requesting repaints, and supports an idle-waiting \Settle\ request. The protocol uses a binary handshake and MessagePack framing over TCP.

_crates/egui\inspection/src · high confidence

This change adds the \egui\_kittest\ crate, a new testing harness for egui applications. It provides a \Harness\ builder to configure and run UI tests, supporting snapshot comparisons with configurable per-pixel thresholds and OS-specific tolerances via a \kittest.toml\ config file. The harness includes built-in accessibility checks to ensure input widgets have accessible names, supports recording UI sessions as MP4 videos, and offers a custom \Node\ API for interacting with widgets (clicking, typing, scrolling) via both direct events and AccessKit actions.

_crates/egui\kittest/src · high confidence

A new \xtask\ crate has been added to automate common repository tasks, providing a portable Rust-based alternative to shell scripts. It includes a \deny\ subcommand that runs \cargo-deny\ checks across multiple target platforms (including Windows, macOS, Linux, and Android) and automatically installs the tool if missing. The crate is invoked via \cargo xtask\ and is designed to be easier for Rust contributors to maintain than existing shell-based tooling.

xtask · high confidence

The demo app now includes an optional Accessibility Inspector plugin (enabled via the \accessibility\_inspector\ feature) that adds a side panel for debugging the AccessKit tree. Users can open it with Cmd/Ctrl+Alt+I to view the current accessibility node hierarchy, inspect details like role and label, and trigger actions on nodes to test accessibility behavior.

_crates/egui\_demo\app/src · high confidence

The \examples/images\ directory now contains a complete example application that demonstrates how to load and display various image formats in an eframe/egui app. It shows how to use \egui\_extras::install\_image\_loaders\ to enable support for WebP, GIF, and SVG assets, as well as how to load images from remote URLs. The example also illustrates using \corner\_radius\ for styling images and includes a screenshot and README for quick reference.

examples/images · high confidence

Added a new example (\external\_eventloop\_async\) that demonstrates how to integrate an eframe application with a Tokio async executor on Linux. This setup allows the UI and local async tasks to share data without locks or message passing, and supports running CPU-bound tasks via \spawn\_blocking\ to maintain UI responsiveness.

_examples/external\_eventloop\async · high confidence

The examples directory now includes a README explaining that the examples use eframe to set up windows for egui, with links to additional examples and documentation. A new run\_all.sh script has been added to easily run all examples in the directory.

examples · high confidence

Added a new example application demonstrating how to render text glyphs from SVG files using \egui\_extras::SvgGlyph\. The example shows how to override standard characters (like the heart symbol) with tinted SVGs and use private-use Unicode characters for colorful custom glyphs (like Ferris), including configuration for height and baseline offset.

_examples/svg\glyph · high confidence

Added a new example demonstrating how to define and apply custom text styles globally within an egui application. The example shows how to configure specific font families and sizes for various text styles (such as headings, body, and monospace) and apply them to UI elements.

_examples/custom\_font\style · high confidence

Added a new example in \examples/custom\_keypad\ that implements a custom on-screen keypad widget. This example demonstrates how to intercept and manipulate raw input events using the \raw\_input\_hook\ callback, allowing the custom keypad to inject key presses and text into the application's input stream seamlessly.

_examples/custom\keypad · high confidence

The demo library now includes several new interactive examples: a Code Editor for syntax-highlighted text input, a Completion popup for emoji suggestions, a Band demo for animated waveforms, a Code Example showing side-by-side code and UI, a Drag-and-Drop demo, an Extra Viewport demo for multi-window support, a Font Book for exploring available glyphs, a Frame demo for styling containers, a Highlighting demo for widget interaction, an Interactive Container demo using UiBuilder, and a Misc Demos window covering various widgets and layouts.

_crates/egui\_demo\lib/src/demo · high confidence

The demo application now includes four new interactive examples: Custom3d (rendering a rotating triangle via OpenGL/glow or WGPU using paint callbacks), FractalClock (a recursive, time-based line drawing visualization with adjustable depth and luminance), HttpApp (fetching and displaying remote text or images with syntax highlighting), and ImageViewer (exploring image fit modes, rotation, tinting, and UV mapping). These apps are conditionally compiled based on features like glow, wgpu, http, and image\_viewer, and are registered in the demo app module.

_crates/egui\_demo\app/src/apps · high confidence

The repository now includes a comprehensive suite of shell and Python scripts in the \scripts/\ directory to streamline local development and CI workflows. These tools automate common tasks such as running full check suites (\check.sh\), building and optimizing the web demo (\build\_demo\_web.sh\), managing snapshot tests (\accept\_snapshots.sh\, \update\_snapshots\_from\_ci.sh\), and enforcing code quality via custom linting (\lint.py\) and Clippy checks for WebAssembly (\clippy\_wasm.sh\). Additional utilities support publishing crates (\publish\_crates.sh\), generating documentation (\docs.sh\), analyzing binary bloat (\find\_bloat.sh\), and setting up the WebAssembly environment (\setup\_web.sh\).

scripts · high confidence

The emath crate now includes new modules for 1D and 2D alignment (\Align\, \Align2\, \RectAlign\), easing functions for animations (e.g., \quadratic\_in\, \cubic\_out\), and GUI coordinate rounding (\GuiRounding\, \GUI\_ROUNDING\). It also introduces a \History\ struct for tracking time-series data and exposes \Rangef\ for ergonomic float ranges. These additions provide developers with standardized tools for layout positioning, animation interpolation, and precise coordinate handling within the UI framework.

crates/emath/src · high confidence

Added a new \serial\_windows\ example that demonstrates how to open multiple windows in sequence. The application launches a first window, and upon closing it (or clicking the Close button), waits for a short delay before launching a second window, and then a third. The program terminates after the final window is closed. This example also highlights a known limitation where this sequential behavior does not work on macOS.

_examples/serial\windows · high confidence

A new example application has been added to demonstrate how to integrate native file dialogs and handle drag-and-drop file operations. The example uses the \rfd\ crate for opening files and showcases \egui\'s drag-and-drop capabilities, including a visual preview overlay when files are hovered over the window. It also illustrates platform-specific handling for dropped files, displaying file paths on native platforms and file metadata (name, MIME type, size) on WebAssembly targets.

_examples/file\dialog · high confidence

The \egui\_extras\ crate now includes a new \image\ module with \load\_image\_bytes\ and \load\_svg\_bytes\ functions, enabling direct loading of raster images (respecting EXIF orientation) and SVG rasterization with configurable scaling. Additionally, a new \svg\_glyph\ module introduces \SvgGlyph\, allowing SVGs to be used as custom text glyphs via a \GlyphRasterizer\ that overrides installed fonts, supporting color preservation and custom sizing. These features are exposed through the \image\ and \svg\ feature flags respectively.

_crates/egui\extras/src · high confidence

Added a new example that shows how to capture screenshots of the application window and display them within the UI using eframe and egui. The example demonstrates requesting a screenshot via \ctx.request\_screenshot\, handling the asynchronous callback to store the captured \ColorImage\, and rendering it as a texture. It also includes functionality to save a specific region of the screenshot to a file (\top\_left.png\) and toggle between light and dark themes while continuously capturing.

examples/screenshot · high confidence

Added an example in \examples/styling\_engine\ that demonstrates a custom \StyleProvider\ for \egui::Button\. The example shows how to apply styles based on CSS-like classes (e.g., a 'danger' class) and how to edit theme properties (colors, corner radius) live via a control panel, updating the UI in real-time.

_examples/styling\engine · high confidence

The \web\_demo\ directory has been reorganized to serve as the official egui web demo site. This change introduces a new \index.html\ that loads the WASM application with improved error handling and a loading animation, alongside a \multiple\_apps.html\ example demonstrating how to run multiple egui instances on a single page. A \CNAME\ file is added to configure the \www.egui.rs\ domain, and a \.gitignore\ file is created to exclude generated build artifacts (\egui\_demo\_app\_bg.wasm\, \egui\_demo\_app.js\). The local development server is now configured to use port 8765 to avoid conflicts with other services.

_web\demo · high confidence

The shape definitions in \crates/epaint/src/shapes\ have been reorganized so that each shape type (such as \RectShape\, \CircleShape\, \EllipseShape\, \TextShape\, and \PathShape\) is defined in its own file, improving code organization. Additionally, a new \BandShape\ has been introduced to support painting varying-width bands along a line segment, expanding the available drawing primitives.

crates/epaint/src/shapes · high confidence

The eframe crate is introduced with its core public API, including the \App\ trait (defining \logic\ and \ui\ methods), the \CreationContext\ struct for initialization, and platform-specific runners (\WebRunner\ for web, native integration for desktop). This change establishes the foundational interface for writing cross-platform egui applications, exposing features like native window access, storage, and rendering context (glow/wgpu) to the user.

crates/eframe/src · high confidence

The egui-wgpu crate has been reorganized into a dedicated \crates/egui-wgpu/src\ directory, moving all source files (lib.rs, renderer.rs, setup.rs, winit.rs) and adding a new capture module. This change introduces optional screenshot capture functionality (behind the \capture\ feature flag), allowing users to capture the UI to a CPU-readable buffer even when the window is occluded or minimized. The renderer now supports configurable dithering to reduce color banding and includes a \predictable\_texture\_filtering\ mode for consistent snapshot images in testing. Additionally, the winit integration now supports runtime surface configuration changes (present mode and frame latency) and improved surface lifecycle handling to prevent crashes on macOS during live resize.

crates/egui-wgpu/src · high confidence

The \src/lib.rs\ file containing the Rust WASM bindings for the initial GUI implementation has been removed. This eliminates the \show\_gui\ function and associated data structures (\Input\, \PaintCmd\) that previously handled drawing commands like clearing the screen, rendering rounded rectangles, and displaying text via \wasm\_bindgen\ and \serde\.

src · high confidence

The Glow backend's GLSL shaders have been updated to perform color operations in gamma space, which corrects text appearance and improves texture filtering accuracy. Additionally, the fragment shader now includes optional dithering to reduce visible color banding on 8-bit displays, and both vertex and fragment shaders enforce high-precision floats where supported to fix text distortion issues on certain mobile devices and browsers.

_crates/egui\glow/src/shader · high confidence

The native backend now sets the application icon at runtime on Windows and macOS, ensuring the correct icon appears in the taskbar and dock even when launched from external processes like Python. On macOS, the new \WindowChromeMetrics\ API exposes the size of the native traffic-light buttons, and the backend can now position these buttons vertically within a custom title bar when using a full-size content view. Additionally, the persistence storage location is now determined by the \NativeOptions::AppId\ (or \ViewportBuilder::app\_id\) rather than the application title, providing more reliable and consistent state file paths across platforms.

crates/eframe/src/native · high confidence

The web backend has been restructured into a new modular runner system (app\_runner, backend, events, input, text\_agent, etc.) that improves how egui apps run in the browser. Key changes include: better IME and mobile keyboard handling via a dedicated text agent element; improved focus management that prevents sticky modifier keys on alt-tab and handles visibility changes correctly; enhanced touch and gesture support with proper tracking of primary touches and accumulated scale/rotation; canvas positioning that accounts for padding and border to fix coordinate issues; system theme detection that respects prefers-color-scheme; local storage persistence for app state with proper error logging; panic handling that captures and displays stack traces; and configurable renderer selection (glow or wgpu) with proper lifecycle management. The new structure also adds support for drag-and-drop file handling, screenshot capture, and better event propagation control through WebOptions.

crates/eframe/src/web · high confidence

The \egui-winit\ integration has been reorganized into its own \crates/egui-winit\ directory, introducing a new \Clipboard\ struct that supports platform-specific backends (arboard, smithay-clipboard) with a fallback for same-app clipboard, and adds image paste support via \get\_image\/\set\_image\. Window state persistence is now handled by a new \WindowSettings\ module that clamps sizes to monitor bounds and restores positions across monitors, while macOS trackpad momentum scrolling is detected via a dedicated \ScrollMomentumMonitor\ using AppKit. iOS safe area insets are now retrieved to avoid UI overlap with dynamic islands, and the integration uses \web\_time\ instead of \instant\ for time tracking.

crates/egui-winit/src · high confidence

The epaint crate has been reorganized with its source files moved into a \crates/epaint/src\ directory. This change introduces several new types and capabilities: \Brush\ for controlling texture application on rectangles, \ColorMode\ for defining solid or UV-based path coloring, and \RoundedRect\ as a geometry primitive for rounded rectangles. Corner rounding is now handled by \CornerRadius\ (using \u8\ for storage) and \CornerRadiusF32\ (for calculations), replacing the previous \Rounding\ type. Margins are now represented by \Margin\ (using \i8\) and \MarginF32\. The library also adds support for \EllipseShape\, \BandShape\, and allows transforming shapes after tessellation via \ClippedShape::transform\. Additionally, the internal mutex implementation now includes deadlock detection that panics in debug builds if locks are held for more than 10 seconds.

crates/epaint/src · high confidence

The loader subsystem in \egui\_extras\ has been restructured to improve performance and reliability. A new \background\_decode.rs\ module introduces a \DecodeCache\ that offloads image decoding to background threads on native platforms (while decoding immediately on Web), reducing UI thread blocking. This change introduces dedicated loaders for GIF (\GifLoader\) and WebP (\WebPLoader\), enabling support for animated images. The \FileLoader\ now supports percent-decoding in \file://\ URIs and handles Windows UNC paths correctly. Additionally, the \EhttpLoader\ now allows users to attach custom request headers via a \with\_request\_template\ method, and the \ImageCrateLoader\ has been updated to support image plugins and case-insensitive extension matching.

_crates/egui\extras/src/loaders · high confidence

The text layout system has been restructured to improve font handling and cursor precision. Font face parsing and storage are now centralized in a new \FaceStore\, while \Family\ objects own the fallback chain logic, replacing the previous \CachedFamily\ approach. A new \MissingGlyphPolicy\ allows users to choose between rendering a placeholder box (tofu) or panicking when a character cannot be drawn, which is useful for catching missing glyphs in tests. Additionally, text cursors now use strongly typed \CharIndex\ and \ByteIndex\ types, and the \CCursor\ API has been simplified with new methods like \end\_of\_str\ for easier position management.

crates/epaint/src/text · high confidence

Add epaint performance benchmarks; Added UiStack demo and test application; Added regression test for egui\_extras compilation without serde; Added regression test for egui\_inspection with hidden windows; Added snapshot tests for demo library components; Added snapshot tests for the egui demo application; Added test app for size pass and tooltip behavior; Added test application to verify background viewport state reporting; Added test for direct Glow rendering and pointer input state; Added test suite for eframe viewports; Added tests for table and strip sizing with clipped content; Expanded test coverage for egui widgets and features; Expanded test coverage for egui\_kittest harness and accessibility features; New demo tests for clipboard, cursor, grid, ID, input, layout, SVG, tessellation, and window resizing.

The project has updated its dependencies and reorganized its crate structure. Key dependency updates include \accesskit\ to 0.25.1, \wgpu\ to 30.0.0, and \winit\ to 0.30.5. The codebase has been moved into a \crates\ directory, and dependencies are now managed via workspace definitions. Additionally, the \egui\_glium\ backend has been removed from \eframe\, and the \default\_fonts\ feature is now opt-out rather than default.

(dependencies) · high confidence

The repository now includes foundational governance and quality-assurance files: a Contributor Covenant Code of Conduct, contribution guidelines (CONTRIBUTING.md), and a release process checklist (RELEASES.md). Development tooling is configured via .typos.toml for consistent American English spelling, clippy.toml for linting rules, and deny.toml for dependency license and security checks. Repository storage rules are defined in .gitattributes (enforcing LF line endings and Git LFS for images/GIFs), and code ownership is specified in CODEOWNERS.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 53.

• Code Health 90
• Architecture 85
• Maturity 67
• Readiness 71
• Security 66
• Event Sourcing 100
• Accessibility 32
• Performance 91

• 300 commits — 242 feature/other, 58 fixes

• crates/egui — 136 commits
• crates/eframe — 35 commits
• (root) — 30 commits
• crates/epaint — 23 commits
• crates/egui_kittest — 15 commits
• crates/egui_demo_lib — 12 commits
• crates/egui_extras — 10 commits
• crates/egui-wgpu — 9 commits
• tests/egui_tests — 9 commits
• crates/egui-winit — 7 commits
• crates/egui_demo_app — 4 commits
• .github/workflows — 3 commits
• crates/egui_inspection — 3 commits
• crates/emath — 3 commits
• crates/ecolor — 1 commit

• fix: fix(web): prevent entire page from scrolling out of view in Chrome (WASM) (#7888)
• fix: Don't revert external changes to a focused DragValue (#8403)
• fix: Fix "drunk text" bug (#8250)
• fix: Fix #2142 - lost_focus not firing after a mid-frame focus transfer (#8210)
• fix: Fix #8495: Match scrollbar interaction rect to drawn bar rect (remove dead zone) (#8635)
• fix: Fix : an issue where double-clicks were judged as triple-clicks. (#7915)
• fix: Fix AccessKit ScrollIntoView for a Ui with UiBuilder::sense (#8646)
• fix: Fix NaN panic in Scene with zero scene_rect and unbounded zoom (#8622)
• fix: Fix ScrollArea failure by handling horizontal and vertical scrolling separately in the missing place (#8275)
• fix: Fix TextEdit hint text not following horizontal_align/vertical_align (#8332)
• fix: Fix DragValue reporting changes while typing with update_while_editing(false) (#8627)
• fix: Fix Frame::set_wgpu_surface_config being ignored (#8442)
• fix: Fix ScrollArea::scroll_to_* calls when stick_to_bottom is Active (#8033)
• fix: Fix Sense::drag detecting drags when clicking widget above it (#8396)
• fix: Fix TextEdit layout shift with custom margin; unclipped TextEdit grows to fit text (#8628)
• fix: Fix egui-wgpu build on wasm32-unknown-emscripten (#8454)
• fix: Fix egui_kittest failing to compile without the wgpu feature (#8381)
• fix: Fix a few nightly clippy lints (#8388)
• fix: Fix a flaky test in id::debug_format_tests (#8573)
• fix: Fix burst of extra repaints before request_repaint_after deadlines (#8595)
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

emilk/egui was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.