Project contribution report
Mini UI (Codename)
A lightweight Windows note-board application that blends practical organization with customizable desktop presentation, allowing notes, drawings, folders, and decorative board elements to sit naturally over the user’s wallpaper.
A lightweight Windows note-board application that blends practical organization with customizable desktop presentation, allowing notes, drawings, folders, and decorative board elements to sit naturally over the user’s wallpaper.
Mini UI is a Windows desktop note-board application designed to combine lightweight organization with customizable desktop presentation.
Users can create typed notes, checklists, drawings, hybrid notes, folders, stickers, and board objects, then arrange them within a visual workspace that can function as a normal application, pop-out board, or subtle desktop overlay.
The application is intended to remain visually expressive while preserving local privacy, lightweight behavior, and practical daily utility.
The project began as a focused UI and systems case study and developed into a functional independent software product.
- Mini UI began as a focused exercise in interface and application-system design outside a traditional game engine.
- The production goal was to create a lightweight, functional desktop utility that could provide organization without visually disconnecting the user from their wallpaper or desktop presentation.
- Primary constraints included solo development, new desktop-software workflows, performance and memory awareness, Windows-specific interaction requirements, local persistence and recovery, increasing feature scope, visual consistency across many interface systems, and packaging and testing outside a game editor.
- All project material is safe to discuss publicly unless later marked otherwise.
- Founder, Product Designer & Solo Software Developer
- Product concept
- Product design
- UX architecture
- Interface design
- Feature requirements
- Software architecture goals
- Window and desktop behavior
- Notes and workspace systems
- Personalization design
- Persistence and recovery requirements
- Drawing-tool direction
- Quality standards
- Feature acceptance
- Testing
- Defect reporting
- Iteration planning
- Release prioritization
- Visual direction
- Packaging validation
- Own the product vision, requirements, UX, architecture goals, visual direction, quality standards, feature acceptance, testing, correction decisions, and release priorities.
- Direct the notes, workspace, personalization, persistence, recovery, drawing, Windows-integration, and packaging requirements.
- Inspect, test, report defects in, and validate implementation produced through the AI-assisted engineering workflow.
- Develop a locally persisted Windows workspace supporting notes, drawings, folders, board objects, desktop-overlay behavior, personalization, recovery, and packaged application testing.
Adaptive Desktop Overlay and Window Control
Contribution
- Supports normal application mode, pop-out board mode, and desktop-overlay mode.
- Supports desktop lock, click-through behavior, Privacy Hide, Quick Capture, and global shortcuts.
- Supports fullscreen-aware hiding, system-tray operation, single-instance behavior, and saved window and workspace state.
- Uses WPF custom window chrome, Windows tray integration, global shortcut handling, Win32 interoperability, foreground-window and fullscreen detection, and click-through behavior.
Result
Created a workspace capable of behaving as both a normal productivity application and a subtle visual extension of the user’s desktop.
Workspace, Notes, and Local Persistence
Contribution
- Supports typed notes, checklists, rich-text behavior, drawing notes, hybrid notes, folders, stickers, and board items.
- Supports copy and paste, saved arrangements, board panning, per-note opacity, search, organization, and workspace state.
- Uses local save and load, System.Text.Json, workspace schema migration, backup and restore, recovery handling, persisted settings, and saved note and board state.
- Maintains local persistence without a cloud dependency.
Result
Built a private local workspace that preserves both user content and visual arrangement across sessions and software revisions.
Centralized Personalization and Theme System
Contribution
- Supports Themes and Colors, Geometry and Density, Typography, Theme Effects, Board Appearance, Board Item Defaults, and Note Appearance.
- Uses centralized theme architecture, Wallpaper Blend, custom colors, imported typography, deterministic color suggestions, note effects, grid styles, board appearance controls, and per-note visual settings.
- Includes visual effects such as Frosted, Rain, Pulse Rim, Lightning Rim, Coded Rim, Neon Bloom, Ember Edge, and Spectral Mist.
Result
Created a scalable visual system that allows the utility to adapt to different wallpapers, preferences, and desktop aesthetics without fragmenting the interface architecture.
Drawing Surface and Rendering Performance
Contribution
- Implemented support: WPF drawing and ink behavior, a drawing surface, tile-based rendering, stable tile composition, O(1) tile lookup, precise dirty-region tracking, cache cleanup, LRU-style resource management, simplified performance mode, and live drawing synchronization.
- Planned or in development: pen tilt, barrel-button eraser, dual brush, texture and grain, brush wheel, stroke prediction, and hardware stylus validation.
Result
Improved the stability and scalability of the drawing system while establishing the foundation for more advanced brush and stylus behavior.
- 01Product goal
- 02Requirements scaffold
- 03Focused system prototype
- 04Implementation
- 05Packaged test
- 06Defect review
- 07Correction
- 08Cleanup and polish
- 09Next feature
- Product features are divided into focused implementation phases.
- Codex assists with scaffolding, implementation, refactoring, debugging, and test preparation.
- Every feature is reviewed inside the running application.
- Packaged Windows builds are tested rather than relying only on source compilation.
- Defects and missing behavior are documented.
- Focused correction passes are issued.
- Notes, board objects, workspaces, settings, personalization, persistence, and drawing are repeatedly retested.
- Builds and schema revisions are versioned as the application evolves.
- Functionality and user experience determine whether a feature is accepted.
- Mini UI is directed and validated by Ruin as a solo independent software product.
- Codex materially assists with scaffolding, implementation, refactoring, debugging, and test preparation.
- Ruin reviews implementation through source inspection, packaged-build testing, defect reporting, focused correction passes, and manual validation.
Problem
The personalization router distinguished only between Themes and Overview, causing several personalization categories to resolve incorrectly.
Solution
Replaced the fragile routing behavior with a stable enum-driven personalization router.
Outcome
Each personalization category could reliably open its correct panel.
Problem
The drawing surface experienced tile-composition, caching, and live-update issues that reduced stability and performance.
Solution
Reworked the rendering path using O(1) tile indexing, stable tile composition, precise dirty bounds, cache and LRU cleanup, and simplified performance behavior.
Outcome
Produced a more stable drawing pipeline and more predictable live rendering in the packaged application.
Problem
Wallpaper Blend did not consistently route, update, or persist through the personalization and board-theme systems.
Solution
Repaired routing, state binding, theme integration, and persistence.
Outcome
Wallpaper Blend became a verified personalization control that remained consistent after navigation and restart.
Testing and review
- Validated Debug and Release builds.
- Ran CoreTests and packaged executable smoke tests.
- Tested navigation, persistence and restart behavior, backup and recovery, and workspace schema migration.
- Checked themes, personalization, board objects, notes, drawing, and tile rendering.
- Tested tray behavior, single-instance behavior, custom windows, and pop-out mode.
- Approximately 50 board items and 25 notes were exercised during one internal personalization and stability test.
Iteration
- Reviewed board-object and note-volume behavior.
- Checked memory stability.
- Verified drawing and tile-rendering corrections.
- Retested routing, persistence, recovery, and personalization after correction passes.
- Treated the internal object-and-note exercise as a test example rather than a public benchmark or guaranteed product limit.
Mini UI currently exists as a functional packaged Windows x64 application with note creation, folders, board objects, desktop and pop-out modes, drawing support, local persistence, recovery, customization, shortcuts, system-tray integration, and a centralized personalization framework.
- Visual polish
- Expanded brush and stylus functionality
- Interaction refinement
- Hardware validation
- Additional grid and board options
- Context-menu cleanup
- Final release preparation
- Steam presentation
All Mini UI media must be verified and cleared for public portfolio use before launch. Every supplied item must include contribution context, a caption, and descriptive alt text.
Related public links
No public product, store, download, or distribution link currently exists.
- Core technology and development workflow
- C# · XAML · WPF · Modern .NET · System.Text.Json · WPF InkCanvas · Custom drawing surfaces · Windows Forms NotifyIcon · Win32 interoperability · Codex · Git · GitHub · Windows development environment · Command-line build tooling · CoreTests · Packaged Windows x64 testing
- AI-assisted engineering workflow
- Mini UI was developed through an AI-assisted engineering workflow using Codex for project scaffolding, implementation support, refactoring, debugging, and test preparation. Ruin defined the product vision, requirements, UX, visual direction, architecture goals, feature acceptance criteria, and release priorities. Every generated implementation was reviewed through source inspection, packaged-build testing, defect reporting, correction passes, and manual validation.
- Learned desktop-software architecture outside a game engine.
- Strengthened systems and product-design skills.
- Improved long-term feature planning.
- Learned to centralize shared visual and interaction systems.
- Improved persistence, recovery, and schema-migration awareness.
- Strengthened packaged-build testing.
- Learned to validate AI-assisted implementation through repeatable tests.
- Improved performance-conscious drawing and rendering design.
- Recognized the importance of stable routing and reusable services as a product grows.
- Learned to prevent visual customization from fragmenting the underlying UX.
Mini UI demonstrates Ruin’s ability to direct and validate a substantial desktop-software product across UX, system architecture, Windows integration, persistence, personalization, testing, and iterative release development.
Hiring relevance
- UI / UX Designer
- Product Designer
- Tools Developer
- Systems Designer
- Software Developer
- Technical Designer
- QA
- Product Owner / Producer
- Multidisciplinary Generalist