your application code holds all state. the gui library is a dumb function called every frame to draw that state. it retains nothing between calls. a gui is data visualization with mouse input.

layout is a simple cursor advancing sequentially. widgets are drawn at the cursor and then the cursor moves. you arrange widgets by calling their functions in order. a new row is a function that resets the horizontal cursor and advances the vertical one.

input events are consumed immediately. a button function checks if the mouse coordinates are within its calculated bounds for that frame. if a click event exists, the function returns true.

widget identifiers are generated implicitly. a hash of the source file and line number creates a unique id. this allows the library to track which widget is being moused over or clicked across frames.

widget functions append simple draw commands like `draw_rect` or `draw_text` to a buffer. a single `end_frame` call iterates through the command buffer and sends it to the graphics api.

the steam page describes the core simulation loops using precise, technical language for the political and economic mechanics. all screenshots are unretouched captures of the actual interface during play.

the capsule art is a high-contrast vector graphic derived directly from the game's symbology. its purpose is informational, like a technical diagram.

the trailer is a screen capture of the game being played. it demonstrates a complete causal chain within the system. a player makes a choice and the trailer shows the consequences propagating through the simulation.

every interactive ui element has a comprehensive tooltip on hover explaining its function and current state. discovering the mechanics is part of the game.

player character sifts through app profiles. each profile combines algorithmically generated buzzwords, curated self-deception, and demands masked as preferences. player sets arcane filters, attempting to find the least offensive option.

messaging system features dialogue options for navigating npc delusion matrices. npcs operate on internally consistent broken logic derived from terrible internet takes. an npc might believe healing crystals cure ailments or star signs dictate global economics. responses turn defensive, aggressive, or abruptly disengaged when worldviews aren't validated.

date encounters become endurance minigames. player survives monologues without showing dissent or navigates conversations where every reply triggers landmines. resources like 'composure' and 'funds' dwindle during encounters. available verbs include "feign agreement", "attempt deflection", "check phone for fake emergency", "silently endure".

npcs evaluate using flawed internal rulesets. they ghost players for statistically common phrases they've labelled 'microaggressions' based on niche forum posts. they demand financial tribute for 'emotional labour'. successful navigation placates npcs momentarily, leading to further draining interactions.

outcomes generate ironic achievements for experiencing digital torture forms. players unlock more unhinged npc archetypes. goals involve survival, escape from the app ecosystem, or compiling comprehensive dossiers on pervasive digital madness.

your data is king. you fucking own it. the ui is a dead simple, traceable pipeline from that data straight to pixels. state management belongs to you entirely. you change data, the ui updates. that simple.

layout is fucking algebra. clear rules, logical constraints. you define how shit fits together, and it fucking does. debugging means looking at numbers and simple geometry.

events are direct function calls. a click happens, your code runs. user input translates to data changes or direct actions, all explicitly controlled by you.

rendering is immediate and understandable. you build draw lists from data each frame. relevant sections update when data changes. animation means interpolating your data and redrawing. you retain full control over animation.

you see the memory. you see the cpu work. performance is a clear consequence of your code. the system itself provides its function with minimal, understandable overhead. this system provides basic fucking building blocks and clear interfaces. you, the developer, are in absolute goddamn control. build your components from the ground up. everything is open to inspection.

target an aggressively narrow, overlooked niche.
build complex, interlocking systems that demand deep user engagement.
your unfiltered personality and direct communication become the brand.
design for modding and user extensibility from the start.
solve a unique, acutely painful workflow problem that sticks users to your solution.
focus on craft; build something so idiosyncratic it’s hard to copy well.
iteratively improve what you build; outlast the slop through persistence.