Modern software engineering has entered an era of fragmented intelligence. On any given Tuesday, a developer might start their morning with Claude Code for complex refactoring, switch to Codex CLI for rapid script generation, and lean on OpenCode for open-source experimentation. While this multi-model approach maximizes productivity, it creates a hidden tax of cognitive friction. To understand how much of their budget is being consumed, developers must break their flow, navigate to multiple heavy web dashboards, and parse through sterile billing tables. The cost of AI is currently measured in spreadsheets and anxiety, leaving a void where a tangible sense of progress should be.
The Cosmic Economy of AI Tokens
Tokenova addresses this friction by treating token consumption not as a financial liability, but as a generative resource. The application operates as a lightweight resident in the macOS menu bar or Windows system tray, silently monitoring background activity to transform raw numbers into a personalized celestial map. The core mechanic is simple: every 200,000 tokens consumed triggers the creation of a star. These stars are not uniform; they are randomly assigned one of 12 distinct shapes based on a seed value, ensuring that a developer's sky is a unique reflection of their specific workload.
While stars provide a steady stream of feedback, the system introduces high-stakes scarcity through planet generation. A planet is triggered only when a single session exceeds 1 million tokens or when the total cumulative usage hits the 20 million mark. These celestial bodies are drawn from a catalog of 31 types, governed by a strict rarity hierarchy. The distribution is weighted heavily toward the common, with Common planets appearing 70% of the time, Rare at 20%, Epic at 8%, and Legendary at 1.9%. At the absolute peak of the hierarchy sits the Mythic grade, with a 0.1% spawn rate. This probabilistic reward system shifts the developer's perspective from monitoring a depleting balance to collecting rare digital assets.
This visualization extends to the very structure of the user's galaxy. Each day, the system selects one of six layout archetypes—Spiral, Elliptical, Irregular, Binary, Open, or Nuclear—based on the daily seed. Because these seeds are deterministic, users can revisit their historical galleries and see the exact arrangement of their past work. The system even accounts for the necessary silence of a day off; when no tokens are consumed, the canvas displays a moon and stars, granting the user a Sleeping Universe achievement. This ensures that the tool tracks the rhythm of the developer's life, not just the intensity of their compute.
Engineering the Local-First Data Pipeline
Beneath the aesthetic layer of stars and planets lies a sophisticated data normalization engine designed to handle the disparate logging habits of various AI tools. The technical challenge is that every AI CLI writes its history differently. Claude Code records its activity in `~/.claude/projects/*.jsonl`, while Codex CLI utilizes a date-structured path at `~/.codex/sessions/YYYY/MM/DD/*.jsonl`. To capture this data without polling the CPU into exhaustion, Tokenova employs the notify service, a file system change notification mechanism that alerts the app the instant a new log entry is appended to these JSONL files.
OpenCode presents a different architectural hurdle. Unlike the text-based logs of its peers, OpenCode stores data within a SQLite database named `opencode.db`. Because database writes do not always trigger standard file system notifications in a way that is useful for real-time tracking, Tokenova implements a dedicated polling mechanism for this channel, querying the database every 5 seconds. This dual-track ingestion strategy ensures that regardless of whether the tool uses a flat file or a relational database, the data is captured with minimal latency.
Once collected, these fragmented data points are passed through a normalization layer that converts them into a unified `TokenEvent` structure. This process strips away the tool-specific formatting and reduces the data to a common schema, which is then stored in a local SQLite database. By centralizing this data locally, Tokenova avoids the privacy pitfalls of SaaS-based analytics. The entire pipeline is designed for isolation; the only time the application connects to the internet is to check for the latest manifest via GitHub Releases to perform automatic updates.
To maintain a negligible system footprint, the application is built on Tauri 2 and Rust. The choice of Rust for the backend ensures memory safety and high performance during the log-monitoring and normalization phases. On the frontend, the developers eschewed heavy JavaScript frameworks in favor of Vanilla TypeScript and the Canvas API. This lean approach allows the app to render thousands of celestial objects in real-time while keeping the memory usage of the tray popover at approximately 80MB. The full implementation details and source code are available for audit at https://github.com/jkapa0417/tokenova.
Privacy Sovereignty and the FSL License
For the professional developer, the location of data is often more important than the feature set. Tokenova adheres to a strict local-first philosophy, storing all user data in directories such as `~/Library/Application Support/com.tokenova.app/`. By eliminating cloud synchronization, the tool removes the psychological and legal barriers that often prevent developers in high-security corporate environments from using third-party utilities. The data ownership remains entirely with the user, ensuring that sensitive coding patterns or token volumes are never leaked to an external server.
This commitment to transparency is mirrored in the project's licensing. Tokenova utilizes the FSL-1.1-ALv2 (Functional Source License), a hybrid model that balances open-source transparency with commercial protection. Under this license, the source code is open for inspection and personal use, but certain commercial exploitations are restricted. Crucially, the license includes a sunset clause: after two years, the code automatically converts to the Apache 2.0 license, ensuring that the software eventually becomes fully open-source. This strategy allows the creator to maintain project direction and prevent predatory commercialization while guaranteeing the long-term survival of the tool.
Beyond the technicals, the application integrates a 365-day heatmap that visualizes the developer's coding rhythm. By mapping token usage over a year, the tool transforms a series of isolated prompts into a longitudinal study of productivity. It allows a developer to look back and see the exact moment a project peaked in intensity or identify the lulls in their creative cycle. By combining this high-level analytical view with the immediate gratification of the galactic map, Tokenova turns the invisible cost of AI into a visible map of intellectual effort.
This intersection of gamification and local-first engineering suggests a new direction for developer tools. As AI continues to abstract the act of writing code, the value shifts from the lines written to the intent managed. Tokenova recognizes that in an age of infinite generation, the only thing that truly belongs to the developer is the history of their curiosity, now rendered as a constellation of stars.
