Rune Editor 1.8.0

New Features & Key Enhancements

• Negative Zoom Support for Editor and Terminal:
  • Implemented automatic negative zoom scaling (transform: scale(1/zoom)) to prevent viewport breaks and ensure flawless text rendering/cell alignment under dynamic browser and system-level zoom levels.
• Custom Ctrl+Shift+L Command:
  • Implemented our own native Ctrl+Shift+L action to select all occurrences of the current selection, aligning with modern editor standards.
• Reactive Git State Sync & Focus Watching:
  • Implemented zero-cost Git refresh mechanics using native Tauri OS window focus detection (getCurrentWindow().onFocusChanged) and terminal keystroke triggers (terminal-enter-pressed), removing the need for CPU-expensive polling loops while keeping the git state completely fresh.
• Intelligent File Directory Watching:
  • Optimized directory watching to lazily spawn and correctly clean up / unwatch file paths when switching workspaces or directories.

Performance & Optimization

• Optimized Document Updates:
  • Shifted away from heavy constant document update loops. Changed the text update mechanism to ensure lag-free performance even when opening and modifying very large files.
• Comprehensive Codebase Refactor:
  • Dead Code Stripping: Completely removed the unused and uncompiled Agent feature (frontend chat interface, custom hook, store, and agent.rs backend file), reducing compile footprints.
  • Unified UI Dialogs: Moved ConfirmDialog.tsx and QuickPick.tsx into the components/ui/ folder, and removed the duplicate PromptDialog implementation.
  • Decoupled Logic: Extracted UI logic from BranchPicker.tsx into a clean, reusable custom hook useBranchPicker.ts.
  • Zero strict-mode TypeScript compilation warnings after cleaning up unused imports and variables.

Rune Editor 1.7.2 Release Notes

Architectural Improvements & Optimizations

• Persistent Editor Refactor: The editor rendering logic has been drastically simplified.
  • Eliminated hidden, "dummy" editor DOM nodes when no tabs are active, significantly reducing memory footprint.
  • Slashed deep prop-drilling across the layout layers. UI components now natively dispatch commands and read state directly from the global stores.
  • The <Editor> component has been aggressively optimized to accept minimal props, drastically reducing re-render overhead.
• Decoupled Welcome Screen: The Welcome Screen now natively handles command palette dispatching via a global event bus (rune-open-command-palette), allowing it to be seamlessly embedded anywhere without rigid prop requirements.
• Size Reduction: Cleaned up dozens of unused variables, duplicate imports, and unused properties to maintain a pristine, lightweight codebase.

Fixes

• Fixed a bug where typing in the editor would cause the cursor to jump aggressively to the first line by pinning the persistent CodeMirror instances to unique IDs rather than reactive objects.
• Fixed a bug where modifying the search query in the "Replace" panel would inadvertently advance the cursor or trigger a live search while the user was still typing.
• Ensured strict active-tab focus logic, maintaining keyboard focus perfectly when switching tabs or panes.

Release Notes: v1.7.1

Bug Fixes & Performance Improvements

• Fixed "Flashing Terminal" on Windows: Eliminated the severe performance lag and visual flashing that occurred when triggering Git actions in production builds on Windows. All background Git operations now use the native Windows CREATE_NO_WINDOW flag, ensuring they execute completely silently and smoothly in the background without spawning disruptive command prompt windows.
• Fixed Silent Branch Checkout Failures: Resolved an issue where attempting to switch branches with conflicting uncommitted changes would fail silently without notifying the user. The application now properly parses Git's standard output during conflict events, displaying a detailed error dialog indicating exactly which files are preventing the checkout.

Release Notes: v1.7.0

Git Architecture & Backend

• Asynchronous Git Commands: Converted network-bound Tauri git commands (git_commit, git_push, git_pull) to async. This offloads execution from the Rust main thread, resolving application freezing/blocking during heavy network operations.
• Robust Git Error Handling: Updated Rust execute_git implementations to capture both stdout and stderr. If stderr is empty upon a non-zero exit code, the backend now intelligently falls back to parsing stdout (crucial for accurate Git error propagation to the UI).
• Unlinked Branch Handling: Modified git_pull to execute git pull origin HEAD instead of a generic pull, implicitly mapping local branches to origin and bypassing upstream tracking requirement failures.
• New Backend Bindings: Introduced 4 new Rust bindings (git_get_remotes, git_remove_remote, git_get_config, git_set_config) to support arbitrary .git/config reading and writing.

Git UI & Settings Integration

• Git Settings Tab: Introduced a dedicated "git-settings" file type in the tabStore.
  • Exposes local workspace configuration via git config --local.
  • Supports adding/removing named remotes.
  • Supports credential helper configuration (manager, store, cache) directly modifying .git/config to resolve recurring HTTPS authentication failures (PAT integration).
  • Designed cleanly using the <SettingRow> layout primitives, strictly separating presentation from the newly extracted useGitSettings.ts custom hook.
• Loading States & Flicker Prevention: Introduced a boolean isLoading flag derived from gitStore.gitState.loading. This replaces synchronous undefined checks, permanently resolving the race-condition where the UI would flash the "No Repository" fallback before the Rust backend completed its get_git_state evaluation.
• UX: Top-aligned the fallback "Initialize Repository" view to match the structural flow of the primary Git Commit view.

Core UI Components

• Global Toast API: Removed localized toast state from the Git view entirely. Implemented a globally accessible ui.showToast method via UIContext. The <Toast> component is now injected at the root MainLayout level using Solid's <Portal>, ensuring it renders perfectly over all EditorPane splits and sidebars.
• Confirm Dialog Scalability: Added strict max-h-[60vh], overflow-y-auto, and whitespace-pre-wrap styling to <ConfirmDialog>. This ensures that verbose multi-line tracebacks (such as raw Git network failures) remain cleanly scrollable and do not structurally break the viewport layout.

🚀 Rune v1.6.0: The Adaptive Context Menu & Refined UX Update

✨ What's New

• Adaptive Context Menu positioning: Rune's context menus (File Context, Editor Context, Tab Context, etc.) now dynamically adjust their location when clicked close to the window edges. If there isn't enough space at the bottom or right, the menu automatically flips upwards or leftwards and adjusts its height constraint, preventing any layout cutoffs.
• Portal-backed Rendering: Solved deep CSS hierarchy transform issues (especially from CodeMirror container styles) by rendering context menus inside a SolidJS <Portal> mounted directly to the document body.
• Scroll to Dismiss: Just like modern IDEs (such as VS Code), scrolling any container on the page will automatically and smoothly dismiss active context menus.

🛠 Under the Hood (Developer Experience)

• Complete UI/Logic Separation: Successfully separated logic and UI components for context menus:
  • useAdaptiveMenu hook strictly handles coordinate mathematics, boundary constraints, and offscreen measurements using requestAnimationFrame.
  • useContextMenu hook encapsulates event listeners for clicks outside, Escape keys, and scroll interception.
  • ContextMenu component is now fully presentational, located inside components/ui.
• Standardized imports: Cleaned up all consumer views and hooks to reference the modularized @/components/ui/ContextMenu components.

🚀 Rune v1.5.0: The Smart Contrast & Active Synchronization Update

This release focuses on reliability, file synchronization, and UI consistency.

✨ What's New

Active File Watching & Conflict Resolution

Rune now actively monitors files that are currently open in the editor.

When a file is modified externally, Rune uses content hashing to detect changes and potential conflicts. If a conflict is detected, an in-editor notification allows you to review and resolve it without accidentally losing your work.

Smart Theme Contrast

Rune now automatically calculates the perceived luminance of the active accent color.

UI components such as buttons, dropdowns, and interactive controls will automatically adjust their foreground color to maintain readability across both light and dark accent themes.

Updated Notification System

The application updater and other system notifications now use a unified Toast-based notification system for a cleaner and more consistent user experience.

🚀 Improvements

• Improved handling of externally modified files.
• Improved visual consistency across theme variations.
• Reduced UI duplication by standardizing notification components.
• Enhanced theme readability across custom accent colors.

🛠 Under the Hood

Updater Refactoring

Extracted Tauri updater functionality into a dedicated Solid hook, improving maintainability and separation of concerns.

Backend Modularization

Refactored window-state and single-instance management into dedicated Rust modules, reducing complexity in the application entry point.

UI Standardization

Standardized core UI primitives including:

• Toast
• Alert
• Button

This helps maintain a clear separation between presentation and application logic while improving consistency across the codebase.

❤️ Thanks

Thank you to everyone testing Rune, reporting issues, and sharing feedback.

Every bug report, suggestion, and discussion helps shape Rune into a faster, more reliable editor. The file watching system and several refinements in this release were directly inspired by community feedback.

Rune Editor v1.4.0

Welcome to Rune v1.4.0! This release brings major structural upgrades to the Tauri backend and squashes a cross-window context pollution bug.

🏗️ Backend Architecture Overhaul

The massive monolithic lib.rs has been thoroughly dismantled and rebuilt into a scalable, domain-driven architecture.

• Extracted and modularized window.rs, terminal.rs, fs_utils.rs, search.rs, and system.rs.
• Cleaner state management and easier contribution pipelines without merge conflict hell inside the Tauri bootstrap logic.

🐛 Bug Fixes

• Command Palette Workspace Pollution: Fixed a critical bug where searching for files (Ctrl+P) or symbols in a new workspace would incorrectly return results belonging to previously opened workspaces in the background. The Rust backend now properly slices the shared global indexing memory using the active window's current rootPath.

Rune Editor v1.3.0

🔍 Editor & Find/Replace Architecture

We completely overhauled the CodeMirror search/replace UI to provide a seamless, bespoke SolidJS experience that matches Rune's rich aesthetics.

• Custom Find/Replace HUD: Built a completely custom, floating SolidJS component (FindReplace.tsx) that docks perfectly below the titlebar.
• Native Search Override: Disabled CodeMirror's default DOM search panel injection (.cm-search { display: none !important }) while still hooking into its native high-performance Regex/Match engines.
• Real-Time Match Indexing: Intercepted CodeMirror's update listener to perform lightweight cursor iterations, broadcasting real-time match indices (e.g., 5 of 12) natively to our SolidJS UI via rune-search-results.
• Selected Text Pre-filling: Dispatching rune-search-set-query on Find invocation to automatically prepopulate the search box with the currently highlighted editor selection.
• Multi-Cursor Matching: Implemented selectMatches into the keymap, allowing users to hit Ctrl+Shift+L to drop multiple cursors on all active regex/text matches instantly.
• Scroll State Preservation: Engineered a scrollStateCache tracking scrollTop and scrollLeft to guarantee seamless context restoration when jumping between massive files and editor tabs.

🖥️ Terminal Panel Reactivity

• Workspace Isolation: Refactored useTerminalPanel.ts to implement a reactive createEffect hooking directly into the rootPath. Terminals are now strictly isolated per workspace—switching workspaces instantly executes a kill_terminal backend invocation and spins up a fresh PTY instance in the new directory.
• Cross-Window ID Collision: Replaced sequential custom IDs with crypto.randomUUID() to completely eliminate terminal state pollution between deeply nested window instances.

⚙️ Backend & Build Systems

• Tauri Auto-Updater Configured: Hooked the @tauri-apps/plugin-updater directly into our front-end. Resolved critical v2 capability locks by explicitly whitelisting "updater:default" and "process:default" in default.json.
• Updater Generation Script: Wrote an automated Node utility (generate-latest-json.js) to scrape .sig signatures from both Windows (nsis) and Linux (appimage) output bundles, formatting them into the latest.json standard required by Tauri's secure Github-release update pipeline.
• Docker Artifact Extraction: Appended a lightweight Alpine container task to our build-linux.ps1 workflow, successfully mounting the locked Docker compilation volumes and ripping the final AppImage, DEB, and SIG artifacts back into our local target/release/bundle/linux/ filesystem for publishing.

🐛 Bug Fixes

• Async Cleanup Panic: Fixed a critical SolidJS hydration warning in useIndexerProgress.ts where onCleanup was being orphaned outside the render tree due to await blocks. Migrated to asynchronous promise chains (.then()) to lock cleanup registration into the synchronous initialization phase.
• Reactivity Escapes: Patched missing variables (matchCount) from hook exports, and fixed scoping issues with findReplaceShortcutHandler failing to unregister during CodeMirror destruction.
• Favicon Ghosting: Scrubbed legacy favicon.ico calls preventing 404 console flooding during active development.

Rune v1.2.0: The Performance Update 🚀

Rune 1.2.0

This release focuses on moving more expensive operations into the native Rust backend and reducing unnecessary work on the UI thread.

⚡ Performance Improvements

Native Fuzzy Search

The Command Palette now uses a custom zero-dependency fuzzy matcher written in Rust. This significantly reduces JavaScript allocations and improves responsiveness when searching large workspaces.

Faster File Explorer

Directory traversal and filtering are now handled natively in Rust. Ignore rules and common directories such as node_modules are applied during traversal, reducing UI stalls when expanding large folder trees.

Background Markdown Rendering

Markdown preview generation has been moved off the main UI path using pulldown-cmark, preventing large Markdown files from blocking editor interactions.

Native Bulk File Operations

Copying, moving, dragging, and pasting large folder structures now use native filesystem operations instead of sequential JavaScript-driven workflows.

🐛 Bug Fixes

Settings Persistence

Fixed an issue where global and workspace settings were not reliably persisted. Configuration updates now use a stabilized debounce mechanism, ensuring settings are correctly written and restored across sessions.

Workspace Search UI

Fixed a rendering issue that could cause the Workspace Search loading indicator to disappear under certain UI scaling conditions.

🛠 Under the Hood

• Reduced binary size through compiler and build profile optimizations.
• Simplified the Windows packaging pipeline around NSIS.
• Continued refactoring backend services to reduce unnecessary IPC overhead.
• Moved more expensive operations into native Rust execution paths.

❤️ Thanks

A huge thank you to everyone who downloaded Rune, tested it, reported bugs, and shared feedback.

Special thanks to the early users from Reddit who took the time to install Rune, test it in real-world workflows, and provide valuable feedback. Your bug reports and suggestions directly helped shape this release.

Release Notes - Rune 1.1.0

Rune 1.1.0 brings important bug fixes and performance improvements, ensuring a smoother and more robust editing experience.

What's New

🐛 Bug Fixes

• Workspace Indexing Limits: Fixed a critical issue where the workspace indexer could escape the project folder via NTFS directory junctions on Windows. The indexer is now strictly sandboxed to the project root directory.
• Zoom Precision: Fixed floating-point calculation errors that caused ugly fractional numbers (e.g., 1.2000000000000002) to appear in the Global Zoom settings.
• Reset Zoom Logic: Fixed an issue where the "Reset Zoom" button and keyboard shortcut failed to do anything because zooming implicitly updated the default settings. "Reset Zoom" now reliably snaps the interface back to 100% scale.

⚡ Performance Improvements

• Smarter Indexing Filters: The backend indexer now completely ignores binary files (like .exe, .dll, .pdf, .mp4) and heavy non-code directories (like dist, build, __pycache__, vendor). This dramatically speeds up workspace initialization and search performance.
• Terminal Initialization & State Management: Refactored the terminal component structure into a modular design, improving process lifecycle handling and reducing memory leakage during split-pane layout switching.

Technical Maintenance

• Completely refactored SettingsView.tsx into modular sub-components for better maintainability.
• Reduced React component complexity in MainLayout.tsx by extracting the EditorPane manager.
• Updated Cargo.toml description to better reflect Rune as a "lightweight, beautiful editor".