Features - Order between code symbols reflects their order in the code file when there is no (not even indirect) dependence between them; for example import statements now typically come first - Windows have a modernized look - No more button on log window for inspecting workarounds that are not used anymore Bug Fixes - Small code artifacts on the map are no longer sometimes oversized next to much larger siblings - Codebase windows can be dragged by their full title bar again

Features: - Four changes in conjunction make map pointer mode better for inspecting dependency relations: It additionally highlights the code artifacts that depend on- or are depended on by the hovered artifact path; that neighbourghood appears after a delay of 100ms to emphasize the hovered artifact first; dimming unhovered artifacts is animated and thus more visually stable; dimming is itself more pronounced - Improved dependency detection: recognizing that type parameters are not published to outside the generic type (avoids false positives) - Improved dependency detection: detecting dependencies onto stand-alone navigation expressions (avoids false negatives) - Reduced overlaps between dependencies and code artifacts on the code map through an optimized topological order - Reveal code artifacts in Finder via File menu and context menus (right click in navigator and code map) - Navigator view and pathbar indicate the path to the current scope via symbol fill - Better completeness and consistency across terminology, symbols and help texts Bug Fixes: - Layout update button no longer wrongly flips to enabled look while the mouse hovers over artifacts - Dependency arrow color is better adapted to light system appearance (not just to dark mode) Performance: - The code map visualization is more preformant (smoother), in particular navigation animations and map pointer mode

Features - Navigate into code artifacts by clicking them - Navigate back out with Esc or via toolbar button - Navigating into- and out of code artifacts is animated with a zoom-like transition - Correct relayout animations are now the default, since their performance is now fast and independent of codebase size; no more menu option to toggle animation correctness - Relayout does not happen automatically unless activated via the View menu, so that toggling navigator or interfere with the current layout - A toolbar button allows updating the layout to the current view size (like after window resize or navigator toggle); the button is enabled when the layout is outdated for the current view size - Inspecting code artifacts and their dependencies by mouse hovering is a dedicated display mode selectable in the toolbar or temporarily activated by holding the Option key; it also dims down other elements so dependencies become even clearer - Indication of cyclic content via code artifact border color uses clearer color separation via distinct colors, consistent with other color codes in the app - Dependency arrows indicate dependency strength (number of code-level references) by their thickness; arrows are also visually more prominent and simple - Code artifact siblings (those in the same scope) have consistent title sizes - Code symbol artifacts (those within files) all use the same code symbol (instead of the capital letters signifying Xcode-style symbol types) - The UI of the codebase visualization is generally refined to be calmer and clearer - New windows show a welcome screen with options for directly loading a codebase - The search filter field has moved to the toolbar Bug Fixes - Layout succeeds for all types of code in all normal view sizes; no more "Couldn't find layout for view size" type of screens - Multi-window use is more reliable Performance - Visualization layout engine runs in the background and never blocks the UI anymore; this scales better to large codebases - Codebase folders load faster

- Dependency dtection has been improved across supported languages - Small UI improvements

* Codeface now finally just works out of the box – without any LSP server setup. * You can now also apply it to Swift apps – not just Swift packages. * Currently supported languages: Python, Rust, Swift, Kotlin, Dart (more to come) * UX improvements around opening codebases

Improved: * The menu options to import codebases into the currently focused codebase file have moved to the File menu. * The order in which code artifacts in cycles are laid out is better: more dependencies go in reading direction. * The order of code symbol artifacts is better: When no better criteria applies, order reflects position in file. * The order in which code artifacts are laid out is less random (varies less). * The visualization layout is more balanced in certain parts. (Technically speaking: Tree map splits around components and strongly connected components are now actually centered.) Fixed: * The hint when nothing matches the search filter did not appear immediately when it applied. This is fixed. * The visualization sometimes blacked out and showed a loading spinner (due to a SwiftUI bug). This is fixed.

Improved: * Nested (package-) scopes (as are common in Java and Kotlin) are summarized/collapsed where folders contain only single folders. * Fast animations are again used by default since they don't impact performance as much, but the View menu now provides an option to use perfectly "correct" animations. This is of course no ultimate solution but a good compromise for now. * Pasteboard shortcuts (Copy, Cut, Paste) are back since they are useful for the search term field. * Hints about failing to find a visualization in the given view size are more detailed and helpful. Fixed: * On first view of a scope, there briefly appeared a hint that the view is too small to visualize the scope. That is fixed. * When viewing a folder in code view, the folder symbol on the hint was unconstrained in size. That is fixed.

* Visualization animations are finally smooth, consistent and correct, with only a small performance impact * Visualization layouts have improved in minor details

* Kotlin support support has been improved * Kotlin files have corresponding icons * Codebase files load much faster * Logs provide more feedback from LSP servers * Technical improvements under the hood

New: * Dart support has been improved and Dart files are displayed with the corresponding icon Fixed: * Animations were gone due a known internal Apple bug. This has been roughly fixed with the official workaround. * A UI bug has been fixed where the path bar and the purchase panel where laid out incorrectly. * The detection of code file endings provided by the user has been improved. * Adherence to the LSP standard has been improved in some details.

Fixed: * Management of initial windows has been fixed again, as it still did not work when detached from the debugger * The about panel now has a compact size instead of being stretched out by the system * Auxilliary windows are not being closed anymore on launch since they are not opened by the system on first launch Improved: * The testing dashboard has evolved in the process of debugging (UI and messages)

Fixed: * When the app becomes active and no document is already open, it's supposed to open a new document. This did sometimes not work. * When the app launches it's supposed to close auxiliary windows. This did sometimes not work. Added: * A log level filter on the testing dashboard Improved: * App Store loading errors are now being displayed * The testing dashboard has a nicer interface

New: * A panel that allows you to support the development of Codeface via a subscription * Subscribers can vote on which types of features we'll develop next * A testing dashboard window showing logs for beta testing and technical support Fixed: * Some menu option titles did not update properly * In code mode, the LSPService hint was being displayed for empty files (files without detected symbols) instead of their code * On launch, no document window opened, so no window was visible at all (UX bug) if none were still open from the last session

This update is mostly concerned with a big technical modernization under the hood. We migrated all code to the latest Swift concurrency features, which will be necessary anyway with the next major Swift version and which should improve overall robustness. FIXED: * Because of an issue in an external framework, the first attempt to connect with LSPService sometimes failed. This is now mostly solved via a workaround in Codeface. * The display mode picker did not update properly when the display mode was changed via shortcut / menu option. * The border color of code artifacts sometimes became incorrect after switching macOS between light- and dark mode. CHANGED: * An empty document now always shows hints about LSPService, whether LSPService runs or not. * Other minor adjustments to the UI

New: * There's now a collapsable Inspector view to the right * A few additional keyboard shortcuts Improved: * Several improvements of the user interface * Under the hood, we migrated to the new SwiftUI of macOS Ventura Fixed: * Having multiple codebase documents open was not properly supported * Connecting to an LSP server did sometimes hang * Several UI issues, including the fullscreen toggle

* Minor improvements under the hood * Adaptation to the latest LSPService

This tiny update ... * Adds another hint about LSPService * Adds an indicator and button to check whether LSPService is running * Adjusts some details in the menu, including a fix on Ventura

Fixed: * The Help menu link regarding LSPService has been updated * The web links in the App Store have been updated Improved: * Wording, menu structure and hints have been improved to help new users get going. * The Help menu now links to a general documentation page. That page is still more of a stub at the time of this release but is currently being expanded.

Fixed: * Retrieving a codebase via an LSP server did fail when the relative path of a code file contained spaces * The UI did hang when retrieving a codebase via an LSP server failed

Improved: * Rendering is now much faster, in particular on large projects. However, animations are sometime not as beautiful anymore, in particular related to search. This will be solved later and more intelligently without slowing things down again. Fixed: * A crash that sometimes occurred when selecting an artifact while the sidebar was unfocused and a lower-level artifact was already selected. However, for this we had to position the toolbar items differently. We will hopefully be able to position them in a better way without crashing on the next macOS version (with the next SwiftUI version).

New: * You can now save, open and share codebase files. Such a ".codebase" file contains all information about a codebase. It requires no other file access and no LSP server to load, and it loads quickly. Codeface has thereby turned into a fully fledged document-based app. Also note: Although these files can contain all code, symbols and dependencies, they are quite small. And when zipped (like for sending via Email), they become yet another 90% smaller. Improved: * The path bar now shows the full path (similar to Xcode), from the project root folder down to the artifact over which the mouse hovers. * The UI around loading codebases has been improved in various ways. Fixed: * Sometimes the visualization did not appear after loading. This was a UI update issue.

Improved: * Dependency arrows are laid out with less unnecessary "overlap avoidance", resulting in a cleaner look that makes the dependency structure more apparent. Fixed: * Visualizations of newly selected scopes appear instantly instead of with an unnecessary animation. Other: * We made loads of improvements under the hood that enable new features to come soon :)

New: 1. Only essential dependencies are shown. Those that are already indirectly implied by others have been removed. This makes many scopes look cleaner and easier to understand. 2. Cyclic dependencies are marked red. These are not pruned as in (1). 3. Artifact border colors are more red the more code of their contained artifacts is entangled in cycles. This indicates a fundamental precondition for meaningful and maintainable structure. Improved: * Artifacts in the same dependence cycle are positioned closer together. * Dependence directions are more consistent in scopes with dependence cycles. * Search is now case-insensitive.

Improved: * The code artifact hierarchy and dependencies are visualised clearer. * The layout has been improved, so more code artifact names are displayed. * Search hits are visualized in a more meaningful way that also makes their names more legible. * The app icon has been improved once again. * Root folders that look like packages are displayed with a box symbol, like Swift packages in Xcode.

Fixed: * The hint for files that contain no symbols is back. Improved: * The app icon has been evolved.