<feed xmlns='http://www.w3.org/2005/Atom'>
<title>vega/src, branch master</title>
<subtitle>Surface runtime projecting Pure views across pixel, terminal, CLI, and web.
</subtitle>
<id>http://git.yeowoo.org/vega/atom?h=master</id>
<link rel='self' href='http://git.yeowoo.org/vega/atom?h=master'/>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/'/>
<updated>2026-09-27T12:45:31Z</updated>
<entry>
<title>Name Vega's parts: lib/, surfaces/ and symbols/</title>
<updated>2026-09-27T12:45:31Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-27T12:45:31Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=2920e389f624263efe515d9a5f33f6b822efff5e'/>
<id>urn:sha1:2920e389f624263efe515d9a5f33f6b822efff5e</id>
<content type='text'>
src/ held two parts, the surfaces that show modules to people and the
symbol format with its CPU and GPU drawing. As in Pure (design 009), top
level directories are now the parts, and the README says what each builds.

</content>
</entry>
<entry>
<title>Draw symbols on the GPU from the point table as it is</title>
<updated>2026-09-27T12:02:41Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-27T12:02:41Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=ba76d3810713bb67569114e9458416df0f78687a'/>
<id>urn:sha1:ba76d3810713bb67569114e9458416df0f78687a</id>
<content type='text'>
OpenGL ES 3.1: the file's points go up as one storage buffer, each symbol
gets 16 row bands listing the curves they reach (cut by integer division of
doubled coordinates, so CPU and shader agree), and every pixel of a symbol's
box sums the exact area of its bands' curves, as vega_coverage does.
vega-symbols gpu draws every symbol against the CPU reference and times
1080p pages.

On the Pi 5's V3D it matches the reference (mean 0.001-0.1 levels, worst
4) but takes 142-757 ms a page, 83% of it in the area function. A sorting
network in registers made it 2.3x faster yet computes wrong rows in the
fragment stage with this driver, while the same code is exact in a compute
shader; so drawing each glyph size once into an atlas by compute comes next.

</content>
</entry>
<entry>
<title>Store symbol outlines as point chains, and keep glyph advances whole</title>
<updated>2026-09-27T07:56:47Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-27T07:56:47Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=2acf27f665f8a926d244efa58f6ef2c92d65e8c4'/>
<id>urn:sha1:2acf27f665f8a926d244efa58f6ef2c92d65e8c4</id>
<content type='text'>
Format 2 (VEGASYM2) writes each contour as a chain of 4-byte points, on or
off the curve as in TrueType: endpoints are shared, lines have no control
point, and two off points imply the on point between them. A curve is still
had from one point and its two neighbours, so a GPU can point at curves by
point index and upload the table as it is. Cubics (CFF, SVG curves and arcs)
become quadratic splines the cu2qu way, joins left implied, within a unit.

Files are about half of format 1: 1.3-1.4x a TrueType font's glyf (the
whole subset font's size), 2.0-2.9x CFF, 2.6x smaller than the SVG icons.
Opening checks each symbol's first and last point instead of every curve:
0.34 ms rather than 19 ms for 11,172 Hangul syllables. Points decode
without branching on their flags (9.7 ns a point), still 1.2-10x cheaper
than FreeType's outline.

Glyph advances were half their width since outlines are doubled for
FreeType's implied points; they now match hmtx, and the check says so.

</content>
</entry>
<entry>
<title>Draw glyphs and icons from one symbol format, by exact pixel area</title>
<updated>2026-09-27T07:44:42Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-27T07:44:42Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=523b810d6a9c60342c7f5d74f36fe66f3f2057e9'/>
<id>urn:sha1:523b810d6a9c60342c7f5d74f36fe66f3f2057e9</id>
<content type='text'>
Symbol files (VEGASYM1) hold glyphs and icons as quadratic curves, verified
once per symbol and then read in place. vega-symbols builds them from fonts
(through FreeType, losslessly: twice the font's units keeps TrueType's
implied points whole) and from solid SVG paths (arcs included), refusing by
name what an icon asks for that symbols cannot hold.

The reference rasterizer computes each pixel's covered area exactly: every
curve's integral of clamp(1 - x) dy inside the pixel, split where it crosses
the pixel's sides. The Slug-style two-ray average first tried missed FreeType
by 15.4 levels on average at 12 px; exact area is within 1.2-3.5 at 8-16 px,
and where it differs most it matches 64x64 supersampling, not FreeType.

Reaching an outline costs 4.6-29x less than through FreeType, but the files
are 2.1-6.6x larger than glyf or CFF: design 002 has the numbers and the next
question (points shared along contours, lines without control points).

</content>
</entry>
<entry>
<title>Read module files of any size</title>
<updated>2026-09-26T17:10:52Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T17:10:52Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=2fc9919508d283456deb440579955a631a572efe'/>
<id>urn:sha1:2fc9919508d283456deb440579955a631a572efe</id>
<content type='text'>
A module may now be some 2 MiB; the buffer that keeps the last module's
bytes (for --watch's digest) grows to the file instead of 128 KiB.

</content>
</entry>
<entry>
<title>Give live surfaces a clock and run timers; add a stopwatch</title>
<updated>2026-09-26T16:58:26Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T16:58:26Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=b466603358f8fa5a74551a9819fdd54ad124ef0c'/>
<id>urn:sha1:b466603358f8fa5a74551a9819fdd54ad124ef0c</id>
<content type='text'>
The terminal and the web page set the time events see to the wall clock
and tick an app's timers on time: each round ticks what is due, draws,
then waits for input, a frame or the next tick, and a tick is news to
every open page at once. Scripts have no clock: time MS sets the time
the next events see and tick TIMER ticks, so an app that uses time
replays exactly. A module swap reschedules the timers.

examples/stopwatch.aup runs on every surface; the checks drive it by
script, on a pseudo-terminal by the clock, and on the web page.

</content>
</entry>
<entry>
<title>Swap a running app's module: --watch and the swap command</title>
<updated>2026-09-26T10:54:31Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T10:54:31Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=8e2b3ffadcf83dba74d58dbf9ee2c57cef5f1ad5'/>
<id>urn:sha1:8e2b3ffadcf83dba74d58dbf9ee2c57cef5f1ad5</id>
<content type='text'>
vega tui|web MODULE --watch replaces the running app's module when its
file is written again (aup watch writes it); states keep their values by
name through pure_app_replace and every web page hears of it. The file is
compared by the digest of its bytes, at most five times a second, so a
module of the same size written within the same second is not missed; a
module that does not load leaves the app as it was and is not tried
again. Modules alternate between two slots so a failed load never touches
the running one. Scripts get swap MODULE; whether a module runs frames is
now a property of the screen.

</content>
</entry>
<entry>
<title>Show filtered lists and their shared focus</title>
<updated>2026-09-26T10:33:31Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T10:33:31Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=0d5effd6afe8808296a01db102ca4c247cdcd1af'/>
<id>urn:sha1:0d5effd6afe8808296a01db102ca4c247cdcd1af</id>
<content type='text'>
A list may now be filtered (each t in tasks where !t.done), and several
filtered lists over one list share one focus: the focus view names an
item, so Vega asks Pure which row shows it and highlights it only in the
list that holds it; the other lists have no focus (null in the web
surface's JSON, and the spoken surface names the item where it is). A
click or point on a row points at the item that row shows, and the wheel
on a list without the focus focuses the row under it. Pure's rows now
take a mutable app.

examples/today.aup shows what is open and what is done; its CLI output
matches a model over random adds, moves, toggles and points into either
list, and the web surface leaves the other list without a focus.

</content>
</entry>
<entry>
<title>Style the web page's button and name keys as the TUI does</title>
<updated>2026-09-26T10:10:44Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T10:10:44Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=f0a37de5bc9cf924494878e4ab8d3023ddbb27bd'/>
<id>urn:sha1:f0a37de5bc9cf924494878e4ab8d3023ddbb27bd</id>
<content type='text'>
The Enter button matches the input beside it, and the key legend shows
arrows and short names (↑ ↓ Del PgUp) instead of Pure's key names.

</content>
</entry>
<entry>
<title>Add a web surface: the same spec as a page</title>
<updated>2026-09-26T10:08:29Z</updated>
<author>
<name>eunhhu</name>
<email>necpition205@gmail.com</email>
</author>
<published>2026-09-26T10:08:29Z</published>
<link rel='alternate' type='text/html' href='http://git.yeowoo.org/vega/commit/?id=0054ea8452a811f2745d72ce4b7764ea158f1d5f'/>
<id>urn:sha1:0054ea8452a811f2745d72ce4b7764ea158f1d5f</id>
<content type='text'>
vega web MODULE serves the screen to a browser (127.0.0.1 unless given
--listen): one dependency-free page draws the title, fields, lists as
listboxes and tables, with tones as colors and the focus highlighted. It
asks for the screen as JSON with the rows it can show per list or table,
so only those cells are evaluated, scrolled like the TUI around the
focus. Keys go as KeyboardEvent.code, which is Pure's key naming already;
typed text commits with Enter; a click or the wheel moves the focus
through pure_app_point; an event stream tells every open page of each
change. Scrolling, key presses and text commits are now shared helpers.

The checks drive it against the model (1,200 random steps: title, field,
rows, focus, the window of items with badges and tones), check a table's
columns and cells, post at random to every example, and in headless
Chromium over the DevTools protocol press keys, click a row and type
Korean text into the page itself.

</content>
</entry>
</feed>
