lapce/floem

This system is a Rust-based UI framework that provides a reactive view layer, a comprehensive widget set, and multiple rendering backends including Vello, Vger, Skia, and tiny\_skia. It features a robust editor engine with Vim-style modes and syntax highlighting, alongside a modern event system supporting two-phase dispatch and pointer capture. The framework enables the creation of complex desktop and web applications through features like responsive layouts, animated transitions, and cross-platform native integrations for windows, files, and clipboard operations.

17 changes.

This period centered on the Floem 0.2.0 release, which introduced a major dependency overhaul, new rendering backends (Skia, Vello, Vger), and a refactored reactive API with scope-based context management. Significant features included asynchronous GPU resource acquisition for WASM support, a headless testing harness, and responsive layout utilities. The release was accompanied by a comprehensive suite of examples demonstrating these new capabilities, including virtual lists, animations, theming, and complex UI patterns.

21 changes.

This period focused on replacing the rendering backend with the Vello GPU-accelerated engine and overhauling the text editor with a modular, Vim-style core engine. The work was accompanied by a comprehensive expansion of example applications demonstrating new capabilities such as reactive constraints, async integration, and syntax highlighting.

17 changes.

This period focused on a comprehensive rewrite of Floem's core subsystems, including the event handling, style resolution, view tree, and window management architectures to improve performance and standards compliance. Significant infrastructure work included introducing the Skia rendering backend, establishing a headless testing harness, and adding performance benchmarks. The release was accompanied by a suite of new example applications demonstrating these capabilities, such as pan-zoom interactions, async resource handling, and custom keymaps.

Introduces a new interactive example in \examples/flight\_booker\ that models booking constraints between and within widgets. The application allows users to select between one-way and return flights, with the return date input dynamically disabled when one-way is selected. It validates date formats and ensures the return date is not earlier than the start date, visually indicating invalid inputs with a red background and disabling the 'Book' button until all constraints are satisfied. This example showcases the framework's reactive signals and style binding capabilities.

_examples/flight\booker · high confidence

Introduces a new example application in examples/editor that demonstrates the Floem text editor component. The example showcases features such as shared editor state between two instances, configurable gutter visibility, placeholder text, custom command handling (including ignoring undo events), and document manipulation via buttons.

examples/editor · high confidence

Introduces a new \SkiaRenderer\ implementation in the \skia\ crate, enabling the application to use the Skia graphics library for rendering windows and images. This change adds support for drawing strokes, fills, box shadows, layers, clips, glyphs, images, and SVGs via the Skia backend, integrating with the existing \anyrender\ and \floem\_renderer\ abstractions.

skia · high confidence

This change introduces a new WebGPU example located in \examples/webgpu\. It provides the necessary HTML (\index.html\) and Rust source files (\src/lib.rs\, \src/main.rs\) to run the application in a browser via WASM, using Trunk as the build tool. The example demonstrates basic UI components (labels and buttons) and includes embedded font files (Fira Mono, Fira Sans, DejaVu Serif) to ensure text renders correctly without external dependencies. Users can run this example locally using \trunk serve\.

examples/webgpu · high confidence

A new example application has been added at examples/color\_palette that demonstrates a color palette generator. The application provides interactive sliders for adjusting colors in RGB, HSL, HSV, and LCH color spaces, allowing users to visualize and convert between these different color representations.

_examples/color\palette · high confidence

The examples/todo-complex directory now contains a complete To-Do application that demonstrates advanced UI patterns. The app persists window position, size, theme, and scale settings to disk using confy, and manages a local SQLite database for todo items. It features a rich set of keyboard shortcuts (e.g., Cmd/Ctrl+N for new, Cmd/Ctrl+A for select all, Escape to cancel) and supports window scaling via keyboard modifiers. The implementation showcases reactive state management with signals, debounced database updates, and context-aware command execution.

examples/todo-complex · high confidence

The examples/dyn-container directory now includes a new example demonstrating how to use the \dyn\_container\ component to switch between different views. The example features a toggle button that switches between two distinct views, applying a scale animation and clipping to the content during the transition. It also illustrates the use of \RwSignal\ for reactive state management and demonstrates styling with \row\_gap\ for vertical spacing within the second view.

examples/dyn-container · high confidence

A new 'files' example crate has been added to the examples directory, providing a standalone demonstration of file dialog capabilities. The example showcases how to use the \open\_file\ and \save\_as\ actions with \FileDialogOptions\ to select single or multiple files and directories, as well as saving files. It illustrates the use of \FileSpec\ to filter allowed file types (txt, rs, md) and displays the selected file paths in the UI using reactive signals.

examples/files · high confidence

The examples/keyboard\_handler directory now contains a Rust example demonstrating how to handle keyboard input in Floem. The example shows a container view that is keyboard navigable and registers a key-down event listener to print the pressed key's code, with a specific handler to exit the application when the 'q' key is pressed.

_examples/keyboard\handler · high confidence

Introduces a new example application in \examples/navigation-stack-mobile\ that demonstrates a mobile-style navigation stack using the Floem framework. The example implements a multi-screen flow including a home list of destination cards, a detail screen with booking functionality, and a booking screen, utilizing custom routing, theme-aware styling, and platform-specific modifier keys.

examples/counter-simple, examples/navigation-stack-mobile · high confidence

A new pan-zoom view example has been added to the examples directory, providing a reusable component for implementing pan and zoom interactions in visual editors. The example demonstrates how to handle pointer events for dragging and scrolling, apply affine transformations to a child view, and manage viewport state via signals. It includes support for clipping, image rendering (PNG and SVG), and keyboard shortcuts for inspection, serving as a reference for testing rendering and event handling with transformations.

examples/pan-zoom · high confidence

This change introduces a new \src/platform\ module that provides cross-platform abstractions for OS-level functionality. It adds clipboard support via \copypasta\, file dialog capabilities for opening and saving files using \rfd\, and native menu construction using \muda\ (with wasm32 stubs). These utilities are exposed through the \src/views\ area to enable interactive features like copy/paste, file selection, and application menus.

src/views · high confidence

Added a new example in \examples/responsive\ that demonstrates responsive styling based on screen size breakpoints (XS through XXL) and detects text overflow using the \TextOverflowChanged\ event to dynamically update UI state.

examples/responsive · high confidence

The examples/stacks directory now includes a new demo application that showcases four different stack implementations in the Floem framework: basic stacks using tuple syntax or explicit constructors, stacks derived from iterators, dynamic stacks driven by signals (using imbl::Vector), and virtual stacks optimized for large datasets by rendering only visible items. The example illustrates how to configure vertical and horizontal layouts, apply spacing via row\_gap and col\_gap, and handle runtime updates through signals.

examples/stacks · high confidence

The examples/themes directory now includes a new application that demonstrates dynamic theming. Users can toggle between a blue and a green theme using a button, which swaps the background, text, and border colors. The example showcases style classes for buttons, labels, and frames, along with transition effects for color changes and hover/focus/disabled states.

examples/themes · high confidence

Added a new timer example application that implements task 4 of the 7GUIs benchmark. This example demonstrates handling concurrency by running a timer process that updates the elapsed time concurrently with user interactions, testing the responsiveness of signal updates and the immediate reflection of slider adjustments.

examples/timer · high confidence

Introduces a new rendering backend for the application using the tiny\_skia library. This implementation provides rasterization capabilities for UI elements, including support for text rendering with glyph caching, image drawing, path filling and stroking, and layer/clip management. It replaces previous rendering approaches with a dedicated, high-performance 2D graphics engine.

_tiny\skia · high confidence

Introduces a new example application that integrates the Tokio runtime with Floem to handle concurrent timer updates. The app uses \IntervalStream\ and \StreamSignal\ to drive a progress gauge and elapsed time label, showcasing how to manage async signals and user interactions (such as adjusting duration via a slider) within a reactive UI.

examples/tokio-timer · high confidence

Introduces a new example application in \examples/view-transition\ that showcases dynamic view switching and animation capabilities. The example features a music player interface with play/pause controls, media navigation, and a slider, demonstrating how to apply scale effects, view transitions, and spring-based transitions to UI elements like buttons and containers when toggling between different views.

examples/view-transition · high confidence

The examples/virtual\_list directory now includes a README and source code for a virtual list demonstration. This example showcases the VirtualStack component's ability to handle extremely long lists (up to 1 million items) by only rendering visible items, thereby maintaining performance without manual view tree management.

_examples/virtual\list · high confidence

The widget gallery example has been added to showcase a wide range of UI components and capabilities. It includes demos for labels, buttons (including toggle and secondary click), text inputs with styling and placeholders, checkboxes (custom and labeled), radio buttons, dropdowns, sliders, tabs, and various list implementations (simple, enhanced, and virtual). The gallery also demonstrates advanced features such as canvas drawing with color pickers, image handling (PNG, SVG, JPG) with object fit/position controls, context and popout menus, drag-and-drop with sortable items, file drag-and-drop, clipboard operations, animations with keyframes and transitions, and localization support with multiple languages. The example is organized into tabs for easy navigation and serves as a reference for using the framework's widget set.

examples/widget-gallery · high confidence

Introduces a new example application that allows users to dynamically adjust the window scale factor using Zoom In, Zoom Out, and Reset buttons. The example demonstrates the use of the \set\_window\_scale\ action, reactive signals for state management, and advanced styling features such as hover, active, disabled, and focus-visible selectors on buttons.

examples/window-scale · high confidence

A new example application has been added to demonstrate window sizing capabilities. It configures a window with a default size of 800x600, a minimum size of 400x300, and a maximum size of 1200x900. The UI displays the current window dimensions, which update dynamically as the user resizes the window, and includes a listener for the F11 key to trigger an inspector.

examples/window-size · high confidence

A new example application has been added to demonstrate the usage of scoped reactive contexts. The code shows how to use \Scope::create\_child\ and \Context::provide\ to pass data (specifically a color value) down through nested UI components, allowing child views to reactively access and display context-specific styling.

examples/context · high confidence

The examples/syntax-editor directory now includes a new Rust source file that demonstrates how to implement syntax highlighting within the Floem text editor. This example integrates the syntect library to apply the 'base16-ocean.dark' theme to Rust code, allowing users to see how custom styling, including bold, italic, and colored text, can be applied to editor content via the Styling trait.

examples/syntax-editor · high confidence

The custom\_keymap example now shows how to extend the default editor keymap with custom shortcuts. It includes a binding for Ctrl+D to duplicate the current line and a custom handler for Ctrl+S that prints 'Save!' to the console, while delegating all other keys to the default keymap.

_examples/custom\keymap · high confidence

Added a new example application that demonstrates how to intercept window close requests using the WindowCloseRequested event and how to launch secondary windows. The example implements a confirmation dialog overlay that prevents the window from closing until the user confirms, and supports closing via the title bar or keyboard shortcuts (Cmd+W/Ctrl+W).

_examples/handle\_window\close · high confidence

The ui-events-winit crate is now available, providing a bridge between winit's native input events (mouse, touch, keyboard, gestures) and the ui-events model. The primary entry point is the WindowEventReducer, which manages stateful transformations of winit WindowEvents to produce standardized PointerEvents and KeyboardEvents. This release includes support for keyboard input, pointer movement, button presses, and touch interactions, with an MSRV of Rust 1.73.

ui-events-winit · high confidence

The Inspector tool has been expanded to include a new Profiler tab, allowing users to analyze application performance alongside the existing view hierarchy. This new section visualizes frame data and event timing, enabling developers to identify bottlenecks by viewing frame durations and hovering over specific events for detailed timing information. The change introduces the necessary data structures and UI components to support this performance debugging capability within the inspector window.

src/inspector · high confidence

The application now exposes lifecycle events to users, specifically adding a \Reopen\ event (triggered when the app is activated again, such as clicking the dock icon on macOS) and a \CloseRequested\ event (allowing windows to intercept close actions). This is implemented via a new \AppDelegate\ on macOS that forwards the reopen event, and by updating the application handle to dispatch the close request event to windows. Additionally, the \AppConfig\ now allows configuring whether the application exits when the last window is closed, defaulting to false on macOS to preserve standard behavior.

src/app · high confidence

The renderer now acquires GPU resources (wgpu instance, adapter, device, and queue) asynchronously via a new \gpu\_resources\ module. This change is essential for WebAssembly targets, where blocking the main thread is not permitted; the implementation uses \wasm\_bindgen\_futures\ on WASM and \pollster\ on native platforms to handle the async wgpu initialization without blocking. The module also introduces a \crossbeam\ feature flag to allow swapping the default \std::sync::mpsc\ channel for \crossbeam\ channels, providing flexibility in synchronization primitives for the async request pipeline.

renderer/src · high confidence

The editor now uses a new core engine that supports Normal, Insert, and Visual (Normal, Linewise, Blockwise) modes, along with multi-cursor selections and cursor affinity for better navigation around wrapped lines or inlay hints. It also adds automatic line-ending detection and normalization (converting between CRLF and LF) and introduces auto-surrounding for matching pairs like quotes and backticks.

editor-core/src · high confidence

The vger module now provides a new rendering backend powered by wgpu and the floem\_vger\_rs library, enabling hardware-accelerated graphics. This implementation introduces GPU-based glyph rasterization using a thread-local Swash ScaleContext to handle cache misses, supports rendering linear gradients and solid colors via brush conversion, and manages surface configuration with specific downlevel capability checks (such as vertex storage) to ensure compatibility with the underlying graphics adapter.

vger · high confidence

The animation module now supports keyframe animations, allowing developers to define discrete style states at specific points in time. This change introduces the \KeyFrame\ and \KeyFrameProp\ structures to manage style transitions, along with a comprehensive easing system (\src/animate/easing.rs\) that includes linear, step, and cubic bezier easing functions. Users can now create smoother, more complex animations by specifying easing curves (such as ease-in, ease-out, and spring) for transitions between keyframes, rather than relying on simple linear interpolation.

src/animate · high confidence

Added a new example application in \examples/async-resource\ that showcases the \Resource\ signal for handling asynchronous data fetching. The app fetches GitHub user profiles and avatars, demonstrating how to manage async state, handle API errors (such as rate limits and not found), and render dynamic UI content including images and statistics.

examples/async-resource · high confidence

Added a new example application that showcases various slider implementations, specifically highlighting the new ranged slider feature which allows defining custom value ranges and step increments alongside standard and reactive slider types.

examples/slider-types · high confidence

Developers can now run UI tests and benchmarks without a display using the new \HeadlessHarness\ in \src/headless.rs\, which simulates user interactions and layout passes in memory. Additionally, \src/layout/responsive.rs\ introduces a responsive design system with \ScreenSize\ breakpoints (XS through XXL) and \GridBreakpoints\ to help views adapt to different window widths.

src · high confidence

The layout example application now includes several new interactive demos: a draggable sidebar using the Resizable widget, a holy grail layout with absolute positioning, left and right sidebar layouts using virtual stacks, and a tab navigation component. These examples showcase how to combine flex layouts, scrolling, and custom styling to build common UI patterns.

examples/layout · high confidence

The event system in \src/event\ has been completely replaced with a new implementation that introduces a two-phase dispatch model (capturing and bubbling), z-index-aware hit testing with a 2-entry cache, and support for pointer capture, file drag-and-drop, and custom events. This change alters how events are routed through the view tree, how coordinates are transformed, and how interactions like dragging and focusing are managed, ensuring compatibility with W3C DOM and Pointer Events standards.

src/event · high confidence

The counter example has been completely refactored to use the updated Floem API, replacing the old \AppContext\-based view creation with a modern \IntoView\ approach using \RwSignal\ for state management. The UI now features three buttons (Increment, Decrement, Reset) with comprehensive styling including box shadows, border radius, and specific color themes for hover, active, and focus states. The Reset button is dynamically disabled when the counter is zero. Additionally, the example now supports keyboard navigation and includes an F11 key handler to trigger the view inspector.

examples/counter · high confidence

The application now uses the Vello rendering engine (powered by wgpu and Peniko) instead of the previous renderer. This change introduces a new \VelloRenderer\ implementation that initializes GPU resources, manages surface configurations, and handles scene rendering with support for anti-aliasing and SVG caching. Users will benefit from improved rendering performance and reliability, although this requires a compatible GPU adapter that supports specific wgpu downlevel flags.

vello · high confidence

The editor view has been restructured into a modular component system, splitting the previous monolithic implementation into distinct files for actions, commands, layout, movement, and rendering. This change introduces a new command dispatch system that routes edit, move, scroll, and multi-selection operations through dedicated handlers, while also adding support for phantom text (such as IME preedit and inlay hints) and a dedicated gutter widget for line numbers and current-line highlighting. Users will experience a more maintainable and extensible editor foundation that supports advanced features like modal mode registers, smart tabs, and precise cursor affinity handling without altering the core editing experience.

src/views/editor · high confidence

The style system in \src/style\ has been completely rewritten to improve performance and precision. A new style resolution cache (\cache.rs\) now stores and reuses computed styles based on style identity, interaction state, screen breakpoints, and classes, while validating parent inheritance to ensure correctness. Style recalculation is now driven by a graduated \StyleReason\ system (\recalc.rs\) that tracks specific reasons for updates (such as selector changes, animations, transitions, or inherited property changes), allowing the framework to skip unnecessary work and target only affected sub-elements. The system also introduces a new \StyleCx\ context (\cx.rs\) for managing style propagation and interaction state, along with new traits and types for custom styling (\custom.rs\) and composite style components like borders and shadows (\components.rs\).

src/style · high confidence

The editor-core buffer module has been replaced with a new implementation that includes a diff engine (diff.rs) for comparing text ropes, automatic line-ending detection and normalization to LF in mod.rs, and a comprehensive RopeText trait (rope\_text.rs) for precise cursor and line offset calculations. This change introduces structural updates to how the buffer manages text revisions, undo groups, and line endings, while adding tests (test.rs) to verify editing and motion behaviors.

editor-core/src/buffer · high confidence

The editor now uses a new keymap system that automatically handles Shift modifiers in Insert mode, allowing movement keys like Home and End to extend selections (e.g., Shift+Home) without requiring separate keymap entries. This system supports platform-specific default keybindings for Windows, macOS, and Linux, and enables custom shortcut handling through the new \KeypressMap::handle\_keypress\ API.

src/views/editor/keypress · high confidence

The renderer's text module has been replaced with a new implementation built on the Parley library, introducing a builder-style \Attrs\ API for configuring font families, sizes, weights, colors, and line heights. This change adds support for CSS-style font family parsing (including generic families like sans-serif) and allows users to specify line height as either a multiplier or an absolute point value, providing more granular control over text layout within Floem components.

renderer/src/text · high confidence

The paint subsystem has been reorganized: the renderer logic has moved from the project root into a new \src/paint\ module, introducing \border\_path\_iter.rs\ for detailed border path iteration and \mod.rs\ for paint context and order tracking. Additionally, the renderer abstraction now supports the Skia backend via a new \skia\ feature flag, allowing \SkiaRenderer\ to be selected as the active renderer alongside existing Vello and Vger options.

src/paint · high confidence

The reactive subsystem has been restructured to introduce a new \Context\ API for providing and retrieving values within the scope hierarchy, replacing the deprecated \provide\_context\ and \use\_context\ functions. Signal lifetime management is now explicitly handled via \BaseSignal\ and \SyncBaseSignal\, allowing signals to exist independently of the reactive scope. The system also introduces \DerivedRwSignal\ for bidirectional derived values and refines \Memo\ to use dependency-driven invalidation. Additionally, the \Scope\ API now supports re-parenting via \set\_parent\ and provides dedicated methods for creating local and sync signals, effects, and memos.

reactive · high confidence

The view layer has been restructured to improve performance and correctness. A new \ViewId\ system now manages unique identifiers and storage for views, including proper cleanup of reactive scopes and children. A dedicated stacking context module (\stacking.rs\) implements z-index ordering for event dispatch and painting, ensuring children are bounded within their parent boundaries and using DOM order as a tiebreaker. Additionally, a new \IntoViewIter\ trait allows arrays, tuples, vectors, and slices to be converted into iterators of views, enabling more flexible view composition.

src/view · high confidence

The window-icon example has been updated to demonstrate setting window icons from both PNG and SVG files. The main window now loads a PNG icon, while a secondary window opened via a button can load an icon from an embedded SVG file (ferris.svg) using the nsvg library, showcasing the application's ability to handle different icon formats.

examples/window-icon · high confidence

The windowing subsystem has been restructured into a modular \src/window\ directory, introducing dedicated modules for handle, state, and tracking logic. This change adds a \WindowIdExt::with\_window\_handle\ method, allowing embedders to access the native \raw\_window\_handle::WindowHandle\ for integrating native child windows (e.g., via \wry\). \WindowConfig\ now supports \min\_size\, \max\_size\, and \theme\_override\ settings, while macOS-specific configurations gain \hide\_title\ and \panel\ options. The internal window mapping system has been migrated from a global \RwLock\ to a \thread\_local! RefCell\ for improved concurrency, and platform-specific windowing calls have been standardized to use \winit\ directly instead of the internal \floem\_winit\ wrapper.

src/window · high confidence

Added performance benchmarks for core rendering and layout subsystems; Added tests for boxed view painting and image/SVG layout; New headless testing harness and utilities for Floem UI.

This release updates the project to version 0.2.0, raising the Minimum Supported Rust Version (MSRV) to 1.91 and adopting the Rust 2024 edition. It introduces a comprehensive dependency overhaul, upgrading key libraries such as wgpu to 27.0, Taffy to 0.9.2, and resvg to 0.46, while switching to a published winit fork (floem-winit). The release also adds new rendering backends (Skia, Vello, Vger) and features (editor, localization, serde), alongside numerous new examples demonstrating these capabilities.

(dependencies) · high confidence

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

• CAI 60 → 59 (-1.0)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 81 → 81 (+0.0)
• Architecture 94 → 94 (-0.3)
• Maturity 64 → 59 (-4.7)
• Readiness 71 → 68 (-3.2)
• Security 67 → 75 (+8.3)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 49 → 49 (+0.0)
• Performance 85 (new)

• Change coupling: handle.rs ↔ drag_window_area.rs (src/app/handle.rs)
• Documentation: no contributor guidance (README.md)
• Hotspot: src/event/dispatch.rs (src/event/dispatch.rs)
• Hotspot: src/window/handle.rs (src/window/handle.rs)
• Off-boarding risk: anonymized user #1

• Ambiguous return type for 'selection'. get_selection returns a Range, but get_line_col_char also returns a Range. It is unclear if these represent the same logical concept (the current selection) or if one is a normalized range and the other is something else. Given the name get_line_col_char, it likely returns a range representing line/col info, but returning Range (usize, usize) is ambiguous without context.
• Documentation: no project overview (README.md)
• Duplicate intent/types. RopeTextVal and RopeTextRef appear to be wrapper types for Rope with identical public property access (text). Without distinct behavioral differences in the signature (e.g., different lifetimes or mutability guarantees exposed), they seem like redundant abstractions.
• Inconsistent naming for equivalent operations across modules. Scope uses create_signal for the tuple return and create_rw_signal for the single return. The signal module mirrors this. However, BaseSignal and SyncBaseSignal use rw() to get a read/write interface, while RwSignal is a distinct type. The naming create_signal vs create_rw_signal is slightly inconsistent with the BaseSignal pattern where rw() is a method. More critically, create_signal returns a tuple, while create_rw_signal returns a single object. This is a minor inconsistency in return type patterns but acceptable. The real issue is RwSignal.new_split vs Scope.create_signal returning similar tuple structures but with different names.
• Inverted test pyramid
• Low cohesion: Animation (LCOM4 4) (src/animate/mod.rs)
• Low cohesion: Id (LCOM4 4) (reactive/src/id.rs)
• Low cohesion: Style (LCOM4 13) (src/style/mod.rs)
• Low cohesion: ViewId (LCOM4 7) (src/view/id.rs)
• Low cohesion: WindowState (LCOM4 4) (src/window/state.rs)
• Off the main sequence: floem-editor-core
• Off the main sequence: floem_reactive
• Off the main sequence: floem_renderer
• Off-boarding risk: anonymized user #1
• Orphaned knowledge (editor-core/src/buffer/rope_text.rs)
• Orphaned knowledge (src/event/drag_state.rs)
• Orphaned knowledge (src/event/listener.rs)
• Orphaned knowledge (src/receiver_signal/common/executors.rs)
• Orphaned knowledge (src/text/layout.rs)
• Orphaned knowledge (src/views/navigation_stack.rs)
• …and 23 more

• 1 commits — 0 feature/other, 1 fixes

• src/style — 1 commit

• fix: fix: forward post_paint through Box<dyn View> (#1089)

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

lapce/floem 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.