Skip to content
DeniseUI
Built with it

Showcase

Real programs, not mock-ups. Two of them ship as downloads, one is a separate project, and the rest are in the repository with a command each. Every screenshot here came out of the program itself.

The form designer

applicationdesktopships as a download

A visual designer for .dform files — and a Denise application itself

Palette, canvas, inspector and outline, with snapping guides, alignment, grouping, undo that is exact to the byte, and F5 to run the form. It is not Tauri and not a web page: the canvas draws the form with the same code that will draw it on the panel, so what is on screen is what ships. It is also the first real application written on the toolkit, which is how the toolkit finds out what it lacks.

$ cargo run -p denise-designer -- forms/reference.dform
Source Download
The designer with the reference form on its canvas, a slider selected with eight handles and an alignment guide, and the slider’s properties on the right

squint

applicationdesktopseparate project

A text editor for files too big for text editors

Opens a file of any size instantly and holds almost none of it in memory: a piece table over the file on disk, a sparse line index built in the background, syntax highlighting through syntect. Its whole window is DeniseUI — the TextArea edits the engine’s document through the toolkit’s TextDocument trait, so the widget never learns how big the file is, and the tab strip that closes, drags and renames is the toolkit’s Tabs. It is where several of the toolkit’s newer features were found.

The project
squint showing a Rust source file with syntax highlighting, a tab at the top, line numbers, and a find field at the bottom

table-editor

examplewindow or panel

A record editor: a grid, a form, validation, a modal and CSV

About as much user interface as a small internal tool has. Nine row nodes exist however many records there are; the rules live in table.rs, which knows no widget exists and is unit tested without a display. The same app.rs drives a window and a bare panel — only main.rs differs, by about fifty lines.

$ cargo run -p table-editor
$ cargo run -p table-editor --no-default-features --features kiosk
Source
The record editor on Windows 11: a five-row grid with a selected row, an edit form and a status line

solitaire

examplewindow or panel

Klondike, where a move repaints the piles it touched

A whole game with a mouse, a touch screen or the keyboard: drag the cards, double-click one home, take back any number of moves, and watch a game with nothing hidden play itself out. The bar, the clock and the questions are ordinary widgets. Each of the thirteen piles is a node of its own and the cards in the hand are a node that is moved, so the tree’s own damage is all the damage there is — on a Raspberry Pi 3A+ at 1920×1080 the table painted whole is 20 ms and a card carried across it is 3. The rules live in game.rs, which knows no widget exists and is tested without a display.

$ cargo run -p solitaire
$ cargo run -p solitaire -- --three
$ cargo run -p solitaire --no-default-features --features kiosk
Source
A dealt game of Klondike: the stock with a picture of mountains on its back, four empty foundations, and seven piles each with its last card face up

browser

examplewindow or panel

A small web browser in which every visible thing is a widget

Real pages — Hacker News, Wikipedia, DuckDuckGo Lite — fetched over rustls, parsed with html5ever, laid out by the example’s own block-and-inline engine and drawn entirely through the toolkit. A page’s form controls are the actual TextInput, Checkbox, RadioGroup and Select, and they submit for real. No JavaScript, on purpose. It is the composability proof.

$ cargo run -p browser -- https://news.ycombinator.com
Source
The browser rendering an HTML form with headings, styled text and real Denise form controls

hello

examplestart here

Eighty lines: a message enum, a tree, an event loop

Start here. Half of it is comments, and it builds for a window or for a bare display with one feature flag. The same screen exists as a form file in examples/designed, so the two can be read side by side.

$ cargo run -p hello
$ cargo run -p hello -- --snapshot hello.ppm
Source
The hello example running in a macOS window: a heading, a prompt, a text field and a Greet button

The rest of the examples

Each one exists to demonstrate a single thing, and several of them are the proof behind a claim made elsewhere on this site.

designed

hello again, built from hello.dform instead of from Rust. Read the two side by side.

runtime

Two forms read from files at run time: swap a screen by copying a file over it.

forms

Secondary windows on the desktop: a modeless settings form, a modal, and the state they share.

hello-rect

The damage proof: a bouncing rectangle that repaints two rectangles, not a window.

panel

The widget tree, a modal and a cursor sprite, on bare Linux with no X.

kiosk

The instrumented loop: input latency and frame-time percentiles.

launcher

A menu of the other demos, handing the display to another program and taking it back.

splash

A boot splash on fbdev that survives the framebuffer being replaced underneath it.

arranged

The sizing experiment behind denise-arrange.

typed

Text input and layout, on its own.

Built something with DeniseUI?

Open an issue and it can go on this page. A photograph of it running on a panel is worth more than a screenshot of it in a window.

Tell us about it The repository README