agentleFS
sudoevolvesudoevolve/EUI-NEO/site/llms.txt

EUI-NEO / site

llms.txt2.1k starsChanged 5 days agoApache-2.0View on GitHub

EUI-NEO is a lightweight C++17 desktop UI framework. It provides a declarative UI DSL, retained rendering, built-in controls, and GLFW or SDL2 window backends with OpenGL or Vulkan rendering. These docs describe the current source tree; check release tags when targeting a published SDK. Use this file as the starting point when answering questions or generating EUI-NEO applications. Prefer the public facade and current examples over inferred APIs. Canonical sources: For a normal application: Minimal source-tree integration: Minimal application: For…

1 other project uses a version of this.

Trending

More talk lately.thin dataabout the whole repository

Dec 2025: 0 mentionsJan 2026: 0 mentionsFeb 2026: 0 mentionsMar 2026: 0 mentionsApr 2026: 0 mentionsMay 2026: 0 mentionsJun 2026: 0 mentionsJul 2026: 0 mentionsAug 2026: 1 mentionSep 2026: 2 mentionsOct 2026: 2 mentionsNov 2026: 0 mentions
Dec 2025Jun 2026Nov 2026
Mentions a month of the sudoevolve/EUI-NEO repository that our weekly crawl found: only 5 in all, so this is a hint, not a trend. There is no adoption data for this file yet.

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 1

    1. sudoevolve/EUI★ 2.1k100% same

    Edited · 0

    None found.

    Wrote their own version · 0

    None found.

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

The file

Show its rules and text

We split this llms.txt into the rules it gives an agent

28 rules. About 0 are common, 7 are distinctive, and 21 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈7

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 21

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Use this file as the starting point when answering questions or generating EUI-NEO applications.

    line 5
  2. Distinctive:

    Use C++17 and CMake 3.14 or newer.

    line 19
  3. Very specific:

    Put application functions in namespace app.

    line 21
  4. Very specific:

    Create the executable and call eui_neo_configure_app(target).

    line 23
  5. Very specific:

    Keep add_executable(...) and eui_neo_configure_app(...) unchanged.

    line 94
  6. Very specific:

    Use Row for horizontal toolbars, button groups, and split panes.

    line 111
  7. Very specific:

    Use Column for forms, pages, sidebars, and vertically stacked sections.

    line 112
  8. Very specific:

    Use Stack for local overlays, backgrounds, badges, and absolute positioning.

    line 113
  9. Very specific:

    Use Flow for one continuous wrapping group such as chips or cards.

    line 114
  10. Very specific:

    Prefer .padding(...), .gap(...), .fill(), SizeValue::wrapContent(), flex sizing, and min/max constraints over manual coordinates.

    line 115
  11. Very specific:

    Use components::scrollView for ordinary scrollable content.

    line 116
  12. Very specific:

    Use components::virtualList, components::virtualMasonry, or components::dataTable for large data sets.

    line 117
  13. Distinctive:

    Prefer built-in components before assembling controls from primitives:

    line 123
  14. Very specific:

    Use components::theme::dark() or components::theme::light() as the base token set.

    line 139
  15. Distinctive:

    Do not generate any of these removed APIs:

    line 154
  16. Very specific:

    Put short, single-page framework examples in examples/<name>.cpp only when contributing an API example to EUI-NEO itself.

    line 172
  17. Very specific:

    Put real applications in apps/<name>/app.cpp.

    line 173
  18. Very specific:

    Put distinct pages in apps/<name>/pages/, app-specific reusable UI in apps/<name>/components/, and local media in apps/<name>/assets/.

    line 174
  19. Very specific:

    Keep app.cpp responsible for configuration, the persistent shell, navigation, global overlays, and page dispatch.

    line 175
  20. Very specific:

    Keep dependency direction app.cpp -> pages -> app components -> framework/shared context.

    line 176
  21. Distinctive:

    Treat public headers and current main examples as authoritative when prose and code disagree.

    line 198
  22. Very specific:

    Prefer #include "eui_neo.h".

    line 199
  23. Very specific:

    Prefer eui_neo_configure_app(target).

    line 200
  24. Very specific:

    Never invent builder methods.

    line 201
  25. Very specific:

    Keep IDs stable across frames and namespace child IDs as parent.part.

    line 202
  26. Distinctive:

    Keep component state owned by the page/model.

    line 203
  27. Distinctive:

    Avoid compatibility or glue layers for removed input APIs.

    line 206
  28. Distinctive:

    Verify the exact application target after changes, then run git diff --check.

    line 207

≈ “Common” is an estimate: at least 1 in 5 of the 3,727 llms.txt files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
llms.txt
# EUI-NEO

> EUI-NEO is a lightweight C++17 desktop UI framework. It provides a declarative UI DSL, retained rendering, built-in controls, and GLFW or SDL2 window backends with OpenGL or Vulkan rendering. These docs describe the current source tree; check release tags when targeting a published SDK.

Use this file as the starting point when answering questions or generating EUI-NEO applications. Prefer the public facade and current examples over inferred APIs.

Canonical sources:

- Website: https://sudoevolve.github.io/EUI-NEO/
- Repository: https://github.com/sudoevolve/EUI-NEO
- Releases and SDKs: https://github.com/sudoevolve/EUI-NEO/releases
- Public umbrella header: https://github.com/sudoevolve/EUI-NEO/blob/main/include/eui_neo.h
- Exported components: https://github.com/sudoevolve/EUI-NEO/blob/main/components/components.h

## Fastest Correct Path

For a normal application:

1. Use C++17 and CMake 3.14 or newer.
2. Include only `eui_neo.h` in application UI code.
3. Put application functions in namespace `app`.
4. Define `const DslAppConfig& dslAppConfig()` and `void compose(eui::Ui&, const eui::Screen&)`.
5. Create the executable and call `eui_neo_configure_app(target)`. Do not add a framework app-main source manually.
6. Compose structure with `ui.row`, `ui.column`, `ui.stack`, and `ui.flow`; use `components::*` for standard controls.
7. Give every element a stable, unique ID and finish every builder with `.build()`.

Minimal source-tree integration:

```cmake
cmake_minimum_required(VERSION 3.14)
project(MyProject LANGUAGES C CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_subdirectory(3rd/EUI-NEO)

add_executable(my_app main.cpp)
eui_neo_configure_app(my_app)
```

Minimal application:

```cpp
#include "eui_neo.h"

namespace app {

const DslAppConfig& dslAppConfig() {
    static const DslAppConfig config = DslAppConfig{}
        .title("My App")
        .pageId("my_app")
        .windowSize(960, 640);
    return config;
}

void compose(eui::Ui& ui, const eui::Screen& screen) {
    ui.column("root")
        .size(screen.width, screen.height)
        .padding(32.0f)
        .gap(12.0f)
        .content([&] {
            ui.text("title")
                .text("Hello EUI-NEO")
                .fontSize(28.0f)
                .build();

            components::button(ui, "primary_action")
                .text("Continue")
                .onClick([] {
                    // Update application-owned state here.
                })
                .build();
        })
        .build();
}

} // namespace app
```

Build:

```sh
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel
```

For a downloaded SDK, replace `add_subdirectory(...)` with:

```cmake
find_package(EuiNeo CONFIG REQUIRED)
```

Keep `add_executable(...)` and `eui_neo_configure_app(...)` unchanged. Configure with `-DCMAKE_PREFIX_PATH=/path/to/eui-neo-sdk`.

## Public Programming Model

- Public namespace: `eui` for DSL and shared types; `components` for controls and themed surfaces; `app` for the application contract.
- App contract: `app::dslAppConfig()` describes the window and `app::compose()` declaratively rebuilds the UI.
- Primitive builders: `ui.rect`, `ui.text`, `ui.image`, `ui.svg`, `ui.polygon`, and `ui.shadertoy`.
- Layout builders: `ui.row`, `ui.column`, `ui.stack`, and `ui.flow`.
- Page/runtime state: `ui.state<T>(stableId)` persists a value across composition. Business state may also live in a page/controller object.
- Controlled values: pass the current value to a component and update owner state in `onChange`, or use `eui::Signal<T>` with the component's `bind(...)` method when supported.
- Animation: create a short `eui::Transition`, pass it with `.transition(...)`, and select animated properties with `.animate(...)` when required.
- Multiple windows: use `app::openWindow(DslWindowConfig, composeFn)`.

Composition is declarative. Do not create backend drawing objects in UI code, and do not poll GLFW or SDL input from a component.

## Layout Rules

- Use `Row` for horizontal toolbars, button groups, and split panes.
- Use `Column` for forms, pages, sidebars, and vertically stacked sections.
- Use `Stack` for local overlays, backgrounds, badges, and absolute positioning.
- Use `Flow` for one continuous wrapping group such as chips or cards.
- Prefer `.padding(...)`, `.gap(...)`, `.fill()`, `SizeValue::wrapContent()`, flex sizing, and min/max constraints over manual coordinates.
- Use `components::scrollView` for ordinary scrollable content. It creates its own wrap-content measurement root; make its children report their real heights and do not add a viewport-height wrapper around variable content.
- Use `components::virtualList`, `components::virtualMasonry`, or `components::dataTable` for large data sets.
- `zIndex` changes draw and hit-test order; it does not remove an element from layout. Use `ignoreLayout()` only for genuine overlays or decoration.
- Branch at explicit width thresholds when a multi-column layout must become a single column.

## Component Selection

Prefer built-in components before assembling controls from primitives:

- Commands: `components::button`
- Boolean values: `components::checkbox`, `components::toggleSwitch`
- Exclusive choices: `components::radio`, `components::segmented`, `components::tabs`
- Numeric values: `components::slider`, `components::stepper`, `components::progress`
- Text entry: `components::input`
- Menus and pickers: `components::dropdown`, `components::datePicker`, `components::timePicker`, `components::colorPicker`, `components::contextMenu`
- Navigation: `components::navbar`, `components::sidebar`
- Overlays and feedback: `components::dialog`, `components::toast`, `components::tooltip`
- Data: `components::dataTable`, `components::lineChart`, `components::barChart`, `components::pieChart`
- Media/content: `components::image`, `components::carousel`, `components::markdown`
- Scrolling and large collections: `components::scrollView`, `components::virtualList`, `components::virtualMasonry`
- Custom pointer regions: `components::mouseArea`
- Themed surfaces and text: `components::panel`, `components::card`, `components::text`

Use `components::theme::dark()` or `components::theme::light()` as the base token set. Pass the same tokens and transition through a page for consistent visuals and motion.

## Input And Keyboard Navigation

- Keyboard events use `eui::KeyEvent` with `key`, `action`, `modifiers`, and `scanCode`.
- Text and IME input use `eui::TextInputEvent`; they are separate from key events.
- Element-level `.onKeyEvent(...)` callbacks return `bool` to indicate whether the event was handled.
- Clickable controls participate in Tab / Shift+Tab navigation; Enter / Space activates them. Disabled and hidden subtrees are skipped. Use `.accessibleName(...)` for icon-only buttons.
- Modal dialogs and pickers constrain focus and restore it when closed. Custom overlays can use `.focusScope(open).onDismiss(...)`.
- `ui.accessibilityTree()` exports control semantics and layout bounds. Native screen-reader bridges are not implemented.
- Pointer events use `action`, `button`, `buttons`, and `modifiers`.
- Pointer buttons are `Left`, `Middle`, `Right`, `X1`, and `X2`.
- Standard interaction accepts only the left button by default. Enable other drag or press buttons explicitly with `.acceptedButtons(...)`.
- Pointer capture belongs to the button that started the interaction. Do not emulate capture with global polling.

Do not generate any of these removed APIs:

- `KeyboardEvent`
- `PointerEvent::down` or `PointerEvent::rightDown`
- `pressedThisFrame`, `releasedThisFrame`, or other `*ThisFrame` pointer fields
- compatibility aliases, callback adapters, native button polling, or dual input paths

Current input reference: https://sudoevolve.github.io/EUI-NEO/docs/guides/events.md

## Data Controls And File Dialogs

- `dataTable(...).data(sharedRows, revision)` virtualizes fixed-height rows. Use `.filter(...)`, `.sort(column, descending)`, `.numericSort()`, and `.columnWidths(...)`; callbacks preserve the original source row index. Increment revision after in-place changes. Do not mutate shared data during composition.
- `lineChart(...).data(sharedSamples, revision).range(min, max)` selects realtime mode. `.visibleRange(first, last)` sets a half-open sample interval. Peak-preserving downsampling limits output to about four points per plot unit; missing-data buckets break the line. Realtime mode omits per-point labels, tooltips, and animation.
- `input(...).undoByteBudget(bytes)` bounds combined undo/redo accounting; the default is 8 MiB, with at most 128 snapshots per stack. Zero disables history.
- `eui::platform::saveFileDialog(options)` and `selectDirectoryDialog(options)` distinguish Selected / Cancelled / Failed. `defaultFileName` applies to saving. Dialogs return paths; the caller writes files and handles write failures.

## File Placement

- Put short, single-page framework examples in `examples/<name>.cpp` only when contributing an API example to EUI-NEO itself.
- Put real applications in `apps/<name>/app.cpp`.
- Put distinct pages in `apps/<name>/pages/`, app-specific reusable UI in `apps/<name>/components/`, and local media in `apps/<name>/assets/`.
- Keep `app.cpp` responsible for configuration, the persistent shell, navigation, global overlays, and page dispatch.
- Keep dependency direction `app.cpp -> pages -> app components -> framework/shared context`; app components must not include page implementation headers.

For generated user projects outside this repository, a normal `main.cpp` plus `CMakeLists.txt` is sufficient until the application needs multiple pages.

## Backends And Build Options

Default: GLFW + OpenGL.

CMake cache options:

- `EUI_WINDOW_BACKEND=glfw|sdl2`
- `EUI_RENDER_BACKEND=opengl|vulkan|auto`
- `EUI_BUILD_SHARED=ON|OFF`
- `EUI_BUILD_APPS=ON|OFF` for repository `examples/`
- `EUI_BUILD_USER_APPS=ON|OFF` for repository `apps/`
- `EUI_ENABLE_MODULES=ON|OFF`
- `EUI_ENABLE_TRAY=ON|OFF`

Use a separate build directory for each backend combination. Vulkan requires a Vulkan SDK. SDL2 can use a system package or be fetched by CMake in auto/fetch dependency mode; strict bundled mode does not provide SDL2. Linux tray builds require GLib/GIO development files unless tray support is explicitly disabled.

## Accuracy Rules For Code Generation

- Treat public headers and current `main` examples as authoritative when prose and code disagree.
- Prefer `#include "eui_neo.h"`; normal applications do not need to include `core/` headers.
- Prefer `eui_neo_configure_app(target)`; do not manually add `core/app/glfw_app_main.cpp` or `core/app/sdl2_app_main.cpp`.
- Never invent builder methods. Check the relevant header under `components/` or `core/dsl.h`.
- Keep IDs stable across frames and namespace child IDs as `parent.part`.
- Keep component state owned by the page/model; callbacks update that state.
- Compose global dialogs, sidebars, toasts, pickers, and context menus after normal page content so they render above it.
- Preserve retained-layer caching. Do not disable it as a workaround for rendering or resize bugs.
- Avoid compatibility or glue layers for removed input APIs.
- Verify the exact application target after changes, then run `git diff --check`.

## Documentation

- [Documentation index](https://sudoevolve.github.io/EUI-NEO/docs/README.md): public guides organized by topic; internal plans, reviews, and benchmark records are kept outside the website.
- [Keyboard and control semantics](https://sudoevolve.github.io/EUI-NEO/docs/guides/keyboard-accessibility.md): navigation, focus, overlays, and semantic snapshots.
- [Markdown viewport](https://sudoevolve.github.io/EUI-NEO/docs/guides/markdown-viewport.md): visible-content construction and cache contracts.
- [Linux IME](https://sudoevolve.github.io/EUI-NEO/docs/platform/linux-ime-cursor.md): X11 positioning and troubleshooting.

- [Quick Start and project overview](https://github.com/sudoevolve/EUI-NEO/blob/main/README.md): canonical app and CMake setup.
- [Integration guide](https://sudoevolve.github.io/EUI-NEO/docs/guides/integration.md): SDK, `find_package`, FetchContent, and application entry-point boundaries.
- [DSL reference](https://sudoevolve.github.io/EUI-NEO/docs/guides/dsl.md): builders, primitives, layout, sizing, transitions, and loaders.
- [Components](https://sudoevolve.github.io/EUI-NEO/docs/guides/components.md): component APIs and examples.
- [State](https://sudoevolve.github.io/EUI-NEO/docs/guides/state.md): persistent state and signals.
- [Layout](https://sudoevolve.github.io/EUI-NEO/docs/guides/layout.md): row, column, stack, flow, sizing, and scrolling.
- [Events](https://sudoevolve.github.io/EUI-NEO/docs/guides/events.md): current keyboard, text, pointer, focus, and input dispatch.
- [Animation](https://sudoevolve.github.io/EUI-NEO/docs/guides/animation.md): transitions, easing, and transforms.
- [Images](https://sudoevolve.github.io/EUI-NEO/docs/guides/images.md): local/remote images, SVG, GIF, and caching.
- [Audio](https://sudoevolve.github.io/EUI-NEO/docs/guides/audio.md): miniaudio-backed playback, `eui::audio::Player`, resource paths, errors, and music-synchronized animation.
- [Platform capabilities](https://sudoevolve.github.io/EUI-NEO/docs/guides/platform.md): windows, dialogs, URLs, clipboard, and tray.
- [Modules](https://sudoevolve.github.io/EUI-NEO/docs/guides/modules.md): optional keyboard and serial modules.
- [Network](https://sudoevolve.github.io/EUI-NEO/docs/guides/network.md): asynchronous requests and caching.
- [Async](https://sudoevolve.github.io/EUI-NEO/docs/guides/async.md): asynchronous tasks and runtime result collection.
- [Rendering architecture](https://sudoevolve.github.io/EUI-NEO/docs/architecture/rendering.md): renderer boundaries and backend flow.
- [Dynamic textures and image streams](https://sudoevolve.github.io/EUI-NEO/docs/guides/dynamic-textures.md): RGBA8/BGRA8, NV12, I420, P010 frame submission and OpenGL/Vulkan behavior.
- [Retained layer cache](https://sudoevolve.github.io/EUI-NEO/docs/architecture/retained-layers.md): cache lifecycle, constraints, and backend behavior.
- [ShaderToy](https://sudoevolve.github.io/EUI-NEO/docs/guides/shadertoy.md): pass graphs and OpenGL/Vulkan shader contracts.
- [Runnable examples](https://github.com/sudoevolve/EUI-NEO/tree/main/examples): compact API demonstrations.
- [Gallery application](https://github.com/sudoevolve/EUI-NEO/tree/main/apps/gallery): idiomatic multi-page composition and component usage.

## Optional

- [Chinese README](https://github.com/sudoevolve/EUI-NEO/blob/main/README.zh-CN.md): Chinese project overview and Quick Start.
- [Development and release guide](https://sudoevolve.github.io/EUI-NEO/docs/development/build-and-release.md): repository builds, tests, packaging, and maintenance.
- [UI design skill](https://github.com/sudoevolve/EUI-NEO/blob/main/docs/skills/eui-neo-ui-replicator/SKILL.md): detailed rules for generating or replicating polished EUI-NEO interfaces.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.