Skip to content

About

Explorer is a native Rust + GPUI file manager for macOS with a Windows Explorer-style interface. It includes tabs, dual panes, built-in viewers and text editing, Trash management, and recursive duplicate detection by name, SHA-256, or both.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

19 Commits

Folders and files

Repository files navigation

Explorer for macOS

A native Rust + GPUI file manager with a Windows 11 Explorer-style interface: neutral surfaces, compact tabs and command bar, yellow folder icons, a navigation tree, details/grid views, and an optional preview pane. GPUI renders the interface directly; there is no browser or webview.

Version 0.7.1 built. Compiler checks, the release build, and all 222 automated tests pass: 106 core, 10 worker, 16 native-operation, and 90 rendered GPUI tests. This macOS release redesigns duplicate results with a selectable group list, a matching-path table, filtering, sorting, and a readable full-path/checksum area. A persistent Stop button and Escape cancel the active scan while retaining the last completed results. The finder remains in Explorer’s existing tab strip, and unrelated calculated folder sizes remain cached after file operations. The signed app is dist/Explorer.app; the verified installer is dist/Explorer-0.7.1-macOS.dmg. Full Windows Explorer/Finder parity and Windows builds are not claimed.

Run

Version 0.7.1 shows the user's Trash and accessible Trash folders on mounted volumes in the Trash sidebar location. Folder-size recalculation remains in Properties; selection still calculates automatically. Folder presses pair using at least 500 ms, or the system interval if longer. A bounded input log records the configured/effective intervals, actual event counts, and activation decisions. Quit the running copy and reopen the updated app; the title bar and About Explorer show the version.

Requires macOS 12+, a recent stable Rust toolchain (edition 2024), Xcode command-line tools, and internet access for the first dependency download. GPUI is pinned to 0.2.2 with its runtime_shaders feature: macOS compiles the embedded Metal shaders at launch, so the separate Xcode Metal compiler download is not required.

cargo run --release
# Start in a particular folder:
cargo run --release -- ~/Downloads

The first build compiles GPUI and its dependencies and can take several minutes. Cargo.lock is included for reproducible builds. If necessary, select Xcode with xcode-select.

Create an app bundle:

./scripts/bundle.sh
open dist/Explorer.app

The bundle script builds a release binary, generates a Retina app icon, includes privacy descriptions, and applies an ad-hoc local signature. Distribution signing and notarization are not configured. It does not install or replace Finder.

Install the existing bundle without rebuilding:

./scripts/install.sh

The installer verifies the app signature, copies it into /Applications (or ~/Applications when the system Applications directory is not writable), and launches the installed copy. dist/Install Explorer.command provides the same installer for a double-click in Finder. The app is self-contained: after bundling, the project's target/ build cache can be removed while keeping dist/Explorer.app and the source.

To create a drag-to-install DMG from the existing bundle:

python3 scripts/dmg.py

Open the versioned DMG generated in dist/ and drag Explorer onto Applications. The script verifies the app and image, includes an Applications shortcut, and does not run Cargo or require the build cache. It packages the existing bundle, so run scripts/bundle.sh first when updating the app's source.

Implemented in the source

  • Independent tabs with back/forward history; breadcrumbs, editable paths, ~ expansion, and parent navigation.
  • Expandable folder tree, common macOS locations, mounted volumes, iCloud Drive when present, and persistent folder pins.
  • Virtualized details and four-column grid views; natural filename sorting; sortable name/date/kind/size columns; folders first; hidden-file toggle.
  • Single, Command-click, Shift-click, keyboard, and select-all selection. Anchor/cursor paths survive sorting and refreshed listings, so ranges and arrow navigation keep following the same item.
  • A capture-phase handler checks the visible, clipped row bounds and opens on the second press. It accepts native double-click counts and independently pairs synthetic presses within at least 500 ms (longer system preferences are honored), even without completed-click callbacks. Double-click opening takes precedence over selection modifiers; a single click still selects or toggles selection. Fn does not block opening. Clicks stay keyed to a folder path across re-renders. Refreshes wait until a click sequence ends, and eight pixels of deliberate movement are required to begin dragging. Folder symlinks are browsable, file/application symlinks open with macOS, and broken links report an error.
  • Recursive folder sizes appear in the Size column, grid, preview, Properties, and selected-item totals. One background worker measures selected folders; Properties offers recalculation and cancellation, and View can measure the whole listing. Sorting by Size starts measurement and delays row movement until the current click sequence ends. View → Cancel size calculation stops pending work, and navigating away cancels it automatically. Hidden files count; internal symlinks contribute their own link length and are never traversed. A selected root symlink resolves to its folder target. Totals use logical file lengths, count hard links per directory entry, and exclude directory metadata. Partial results show unreadable entries; explicit Refresh discards cached measurements.
  • Immediate filename filtering; Enter in search performs a cancellable recursive search with a 10,000-result cap. Directory symlinks are not traversed.
  • New folders and empty files; rename; duplicate; recursive copy and move, including cross-volume moves. Copies are assembled in a private temporary directory and published with an exclusive rename; cancellation never cleans a public destination, and read-only partial trees can be removed. Filename collision searches return access errors and honor cancellation.
  • File URL clipboard interoperability with Finder, plus an internal cut clipboard. Failed/cancelled moves retain the unmoved sources for retry; completion does not overwrite a newer clipboard.
  • Internal drag-and-drop copying to folders/sidebar locations, and files dropped from Finder. Dragging out into another app is not implemented.
  • Native macOS Trash with confirmation and persistent restore history for Explorer-deleted items. Trash has Restore, Restore to…, Delete permanently, and Empty Trash controls. Permanent deletion always requires confirmation and checks the selected items' identities and Trash roots. Empty Trash deletes the confirmed snapshot and keeps later arrivals. Read-only folders are supported, and symlinks are removed without following their targets. Double-clicking a trashed item previews it with Quick Look.
  • Session-local undo for successful creates, copies, renames, moves, compression, and Trash operations. Undo verifies file identity and never overwrites a recreated original. Undoing creation/copy moves the result to Trash.
  • ZIP compression through macOS ditto, staged before exclusive publication. ZIP extraction opens Archive Utility.
  • In-app media windows on double-click or Enter, backed by macOS frameworks in the same process. Image files get zoom, fit, Retina-aware actual size, pinch/pan, GIF animation, and previous/next image navigation. Videos get native play/pause, scrubbing, volume, frame stepping, full-screen controls, ten-second skips, and looping. PDFs get continuous scrolling, page navigation, zoom/fit, text selection/copy, search, and a password prompt for locked documents.
  • Open externally in the context menu or media toolbar, plus Quick Look, Finder reveal, and Terminal integration. Closing a video window pauses playback; viewer windows can stay open after the file-manager window closes.
  • The Terminal command opens the selected folder, a selected file's containing folder, or the current folder when there is no single selection. The background menu always opens the current folder. Folder symlinks resolve to their target. Launching runs on a worker thread and reports failures; paths are passed as arguments without shell interpolation.
  • File properties, image/text preview, operation status and cancellation, light/dark themes, and saved tabs/preferences.
  • Background directory loading/search/transfers. The active folder refreshes every three seconds when idle. Stale results from earlier navigations are discarded.
  • Native text input integration with UTF-16/UTF-8 conversion, IME composition, selection, and text copy/paste.

Existing destinations are never silently overwritten or merged. Paste collisions get a copy suffix. Rename conflicts are reported. Copies preserve ordinary file permissions and modification times; ACLs, extended attributes, resource forks, hard-link relationships, APFS clones, and sparse allocation are not yet preserved by the copy engine. ZIP compression uses macOS metadata-aware ditto.

Quit requests are reviewed in the normal event loop. AppKit termination is initially cancelled, then requested again after GPUI releases its App borrow and unsaved-editor decisions have finished. The handler never leaves Cocoa waiting for NSTerminateLater/replyToApplicationShouldTerminate:. Repeated requests share a review, cancellation invalidates stale callbacks, and review errors reset the state so Quit can be retried. Unsaved-editor and active-transfer windows are deminiaturized and brought forward using their exact native window handles. Final native termination runs outside all GPUI updates, avoiding re-entry into the shutdown borrow. Quit diagnostics rotate locally at ~/Library/Application Support/Explorer/quit.log (128 KB, plus quit.previous.log), are private, and are disabled in tests. Automated quit tests use a native-host stand-in that synchronously re-borrows GPUI during shutdown; live Dock/menu/Command-Q validation is still required on macOS.

Right-click a file or folder and choose Copy as path, or press Option–Command–C. Multiple selections copy full paths in display order, one per line, without shell quoting. Symlinks copy the link’s location. The background menu copies the current folder even when items remain selected.

File-manager workflows

  • Dual panes: choose Tools → Dual panes beside the theme button. Each pane has its own tabs, navigation, selection, search, and transfer queue. Click the source pane, select files, and use Copy to other pane or Move to other pane. Internal drag/drop between panes also copies files. Switch back with Single pane; finish/cancel the other pane's queue before hiding it. In split mode, each pane uses a compact layout; wide command bars and detail columns scroll horizontally.
  • Transfer queues: additional Paste, Duplicate, or cross-pane transfers queue behind the current operation. Open Tools → Transfer queue to inspect/remove pending jobs. Pause/Resume operates between copy chunks or atomic file operations; Cancel stops the current job and keeps completed items. Retry failed items retries only failed/cancelled transfer sources. At destination conflicts, choose Replace, Skip, or Keep Both, optionally for all conflicts in that transfer. Replace moves the old destination to macOS Trash and records it for undo; replacing a folder replaces the entire folder, rather than merging its contents. Destination identities are checked again after the decision. Undo and queues remain in memory for this session, separately per pane. Quit is cancelled while either pane has active/queued work and restores that exact window, including from the Dock or a minimized state, with a finish/cancel message. Closing the workspace is also refused while work is active. Unexpected view release requests cancellation without joining a blocked worker on the UI thread; normal quit waits for the queue to be idle before shutdown.
  • Live refresh: macOS directory notifications trigger a debounced reload for creates, removals, renames, and directory metadata changes. A four-second fallback also refreshes file metadata and folders that cannot be watched. Watchers are limited to twelve folders per pane to bound file-descriptor use. Selection is retained by path; updates defer during pointer interactions. Recursive search results are a snapshot: clear the search or Refresh to rerun it.
  • Saved layouts: drag the right edge of a detail-column header to resize it. Column widths, sort order/direction, and grid/detail mode are remembered per folder, for up to 128 folders. Preferences from both panes share the same layout store. Header sorting still works away from the resize handles.
  • Batch rename: select files/folders, right-click, and choose Batch rename…. Edit the pattern, optional literal find/replace in the base name, and starting number. Tokens are {name}, {ext} (including its dot), {n}, {n:03} (zero-padded), and {date} (file modification date in UTC, YYYYMMDD). Every proposed change is previewed before Apply renames or Enter. Up to 4,096 items are supported; invalid names, existing targets, and duplicate targets are rejected. Changes form one undo group. Case-only renames, swaps, and renaming into names already occupied by another selected item are deliberately rejected. A failure/cancel retains completed changes for undo.
  • Better search: type ordinary words to filter filenames, or combine name:report ext:txt,json min:1KB max:20MB after:2026-01-01 before:2026-12-31. For file contents, use content:"invoice paid" ext:txt,json,html and press Enter to search subfolders. Tools → Search filters… explains the syntax. Names/content ignore case; extensions accept comma-separated values; sizes use integer bytes/KB/MB/GB; dates use UTC calendar days. Content search decodes UTF-8/BOM-marked UTF-16 files up to 16 MB and does not follow symlinks. Recursive searches stop at 10,000 matches and report inaccessible entries. This is bounded filesystem search, not a Spotlight/full-disk index.
  • Duplicate finder: choose Tools → Find duplicates… to open a tool tab in the current Explorer window. Choose a folder, match by exact case-sensitive base name (including extension), SHA-256, or both, and choose Files, Folders, or Files and folders. Include subfolders controls whether inner files/folders are candidates. Folder checksums always cover the entire tree, even when only immediate child folders are candidates: sorted relative names, entry types, file content hashes, empty folders, and literal symlink targets. Root folder names are excluded from checksum-only matching. Hidden entries are included; symlinks are never followed or listed as independent file/folder candidates. Metadata such as permissions and timestamps is excluded from checksums. Hard links count as separate paths; no reclaimable-space estimate is claimed. Scans run in the background with progress. A persistent Stop (Esc) button and Escape request cancellation, show Stopping until the worker responds, and prevent late results from replacing the last completed report. Previous completed results remain during rescans and after Stop; incomplete current-scan results are not displayed. Matching options and Scan stay disabled while a scan is active. Select a group on the left to inspect its matching paths on the right; select a path for its full location, Copy path, and Show in Finder. Copy checksum is separate from the group titles. Filter by name, path, or checksum, sort by Most matches or Name, and expand skipped-item details when needed. Switching tabs keeps results and scans; closing the tab cancels its scan. Tool tabs are not restored as folders on restart. Results are read-only. Inventory is capped at 100,000 entries; partial results are labelled and incomplete folder checksums are excluded. Unreadable, changed, and special entries are skipped with up to 100 visible issue details. The scan is a filesystem snapshot, not a transactional lock; scan again before taking action on changed files.
  • Calculated sizes: completed file operations invalidate sizes only for potentially changed paths, their descendants, and their cached parent folders, including the other pane. Unrelated calculated sizes remain visible; unrelated pending calculations resume. Explicit Refresh still clears the cache to force fresh measurements.
  • Folder comparison: choose Tools → Compare folders… beside the theme button. In dual-pane mode it compares the two pane folders; otherwise select a second folder. The separate window recursively compares actual file bytes, reports Same/Changed/Left only/Right only/Different types/Unreadable, and can show differences only. Hidden entries are included, symlink targets are compared without traversal, and scanning is capped at 100,000 entries per side. Compare again reruns the scan; Cancel cooperatively stops it. Show left/right reveals an item in Finder. Comparison is read-only; it never deletes, replaces, or automatically synchronizes files.

Text and code editor

Double-click or press Enter on .txt, .json, HTML, CSS, JavaScript/TypeScript, Rust, Python, Markdown, configuration files, and other supported source formats. Extensionless files such as Makefile, Dockerfile, README, and common dotfiles also open in the editor. A symlink uses its target's type and edits the target without replacing the symlink. Reopening a file brings its existing editor window forward. Use Edit as text in the selection context menu for other regular files, including SVG.

The editor UI, editing model, encoding support, and save logic are Rust. GPUI handles windows, rendering, keyboard/mouse dispatch, IME, clipboard access, and the system Save As picker. A small Rust AppKit delegate hook defers application termination while unsaved editor windows are reviewed, including Quit from a media viewer or the Dock. No Swift, native text view, or webview is added.

Use Command S to save, Shift Command S for Save As, Command F for find/replace, Command G for the next match, Command Z / Shift Command Z for undo/redo, and Command W to close the editor. Return follows the original line ending and current indentation; Tab inserts four spaces. Find is case sensitive. The toolbar exposes wrapping, font size, reload, and editing controls. Vertical scrolling follows mouse-wheel lines and precise trackpad pixels. A visible scrollbar supports clicking the track and dragging the thumb, including dragging beyond the editor surface. Scrolling leaves the caret and document unchanged, keeps wrapped lines scrollable, and allows the final line to be fully visible. With wrapping off, sideways trackpad gestures, Shift+wheel, and the bottom scrollbar move horizontally. Horizontal movement stops at the widest line in the document, stays stable when that line is offscreen, and updates after edits or undo. Enabling wrapping resets horizontal scrolling. Both scrollbar thumbs support clicking and dragging without changing text or selection. Dirty documents show a dot in the title. Closing or quitting offers Save, Save copy, Discard, or Cancel; reloading modified text requires a discard decision. A save failure leaves the edits available.

UTF-8, UTF-8 with BOM, and BOM-marked UTF-16 LE/BE are supported. Existing encoding, BOM, and untouched line endings are preserved. Binary data, malformed encodings, UTF-32, and files larger than 16 MB report an error. Saving stages the complete content privately before atomic replacement, retains file permissions, ACLs and extended attributes, and checks for external content/identity changes before publishing. Read-only files require Save As. Save As creates a new file and refuses to overwrite another existing file; choose a new name to keep a copy. External-edit detection is checked immediately before replacement and is not a transactional lock against concurrent writers. Lines longer than 4,096 Unicode scalars are visually split even with wrapping off. Syntax coloring is lexical rather than language-server analysis; there is no code execution, autocomplete, or compiler integration.

Editor recovery snapshots are written in the background about every two seconds after changes, with a final snapshot when a dirty editor is released unexpectedly. They live as private, atomically replaced files under ~/Library/Application Support/Explorer/Recovery, separately from the originals. A recovery window opens on startup when snapshots exist; Recover documents… opens it manually. Restore opens unsaved text without writing the original; Discard requires confirmation. Saving or explicitly discarding edits removes the snapshot. If the original changed since the snapshot, recovery requires Save As to preserve both versions. A deleted original can be recreated exclusively. Storage is bounded to 64 documents; errors are shown instead of silently evicting unsaved work. A hard crash can lose changes since the last completed snapshot.

For .json/.ipynb, Validate JSON reports line/column errors and highlights the affected line. Automatic validation runs for documents up to 1 MB; the button validates larger supported documents. Format JSON is a single undoable edit and preserves key order, duplicate keys, Unicode strings, number literals (including arbitrary-precision numbers), encoding, and line-ending style. It does not save automatically. Go to line accepts a positive line or line:column, counts Unicode scalar columns, and reveals the caret; Command L focuses that input.

Keyboard shortcuts

Action Shortcut
New / close tab Command T / Command W
Go to path / search Command L / Command F
Search subfolders Enter in search field
Back / forward / up Command [ / Command ] / Command Up
Open / Quick Look Enter / Space
Copy / cut / paste Command C / Command X / Command V
Copy as path Option Command C
New folder / rename Shift Command N / F2
Duplicate / undo file operation Command D / Command Z
Move to Trash Command Backspace
Properties / refresh Command I / Command R
Details / grid Command 1 / Command 2
Hidden files / preview pane Shift Command . / Shift Command P

Verification

Run the core and native operation tests without downloading any crates:

./scripts/test-offline.sh

The core, worker, and native tests create isolated temporary directories. They cover exclusive creation/copy/move/rename, cancellation and concurrent destination replacement, read-only cleanup, inaccessible destinations, descendant-copy rejection, symlink preservation and loops, search, natural sorting, Unicode text and settings, partial/cancelled cut batches, undo conflicts and identity checks, Trash restore/history, restore collisions, permanent deletion limited to selected test items, real ZIP compression, media classification, valid/invalid image and PDF decoding, text encodings, multiline Unicode edits/undo, CRLF navigation, line wrapping, external save conflicts, symlink editing, exclusive Save As, read-only files, permissions, and macOS extended attributes. They never delete from the user's real Trash. Live native Trash, clipboard, Quick Look, and media controls require interactive validation. To keep test output outside the project, set EXPLORER_TEST_OUTPUT_DIR to a temporary directory when running the offline script.

With dependency access, also run:

cargo check --all-targets
cargo test
cargo run

The rendered-row regression tests exercise real GPUI layout and event dispatch without a WindowServer connection:

./scripts/test-ui.sh
# In a restricted environment with cached dependencies:
./scripts/test-ui.sh --offline

These tests reproduce the old Fn-flag failure and cover list/grid activation, native/synthetic click counts, interrupted releases, press pairs without click completions, icon-to-label movement, single-click selection, already-selected and multiply-selected folders, selection modifiers, Enter, folder symlinks, pointer jitter, Terminal availability/target selection, asynchronous folder measurement, size sorting, cancellation/stale results, New/Sort/View menu actions, and editor typing, cursor placement, Unicode undo/redo, saving, find/replace, external-edit errors, unsaved-close cancellation, wheel/trackpad scrolling, scrollbar click/drag, scroll boundaries, caret hit-testing after a partial-line scroll, scrolling wrapped lines, precise horizontal gestures, Shift+wheel, horizontal track/drag, horizontal end limits, offscreen-width stability, width updates after editing/undo, and mouse/keyboard caret placement after horizontal scrolling. The ordinary test command uses unmodified GPUI test support. Offline preparation uses the cached GPUI source and replaces only diagnostic backtraces with std::backtrace, while disabling unused Git utilities; input, layout, rendering, and application code are unchanged. Offline adapters stay under ignored target/ and are never linked into the app. Tests do not write the user's saved preferences or input log.

Before a release, manually validate the window on macOS: tabs/history, multi-selection, internal and Finder file drops, clipboard interoperability, IME, previews, permission-denied folders, native Trash/undo, large transfers/cancellation, image zoom/navigation, video playback/seek/loop/full screen, PDF search/unlock/text copy, and window closure during an operation. These interactive checks are outstanding. The new dual-pane workflows, native directory notifications, large queues with macOS Trash replacements, and recovery startup should also be exercised in a live macOS session. The new editor also needs interactive macOS validation for IME composition, the system Save As picker, window controls, and application-quit decisions across multiple editor/media windows.

Current limits

This is a substantial first version, not complete Windows Explorer parity. This PC browses /, Network & volumes browses /Volumes, and Trash aggregates accessible user Trash folders. Original locations are recorded for items deleted through Explorer; items deleted by Finder/other apps or records older than the bounded 4,096-entry history use Restore to… to choose a destination. macOS may require Full Disk Access for Trash browsing; an access error explains how to enable it. Remaining features include editable permissions/ACLs, Finder tags, Spotlight/indexed full-disk search, thumbnail caching, native drag export, direct SMB/SFTP connections, merging into existing folders, automatic folder synchronization, persistent undo, and crash-resumable transfers. Mounted network volumes can be browsed through /Volumes.

Media decoding and playback use the formats/codecs available in macOS; unsupported or damaged media reports an error, and Open externally remains available. Native media window controls and live playback still require interactive validation. Dates are shown in UTC. Text previews read at most 32 KB. Text cursor movement follows Unicode scalar boundaries rather than full grapheme clusters. ZIP extraction is delegated to Archive Utility and is not tracked in the application's undo stack. Cancellation is cooperative; compression and native Trash finish their current item before stopping. Normal app closure waits for the active worker to clean up; force-killing a process may leave an incomplete copy. If removal of a source fails during a cross-volume move, the completed destination copy is retained and an error is shown.

Preferences live at ~/Library/Application Support/Explorer/session. Tabs, pins, theme, hidden-file visibility, view mode, and preview-pane visibility are saved. Navigation history and the undo stack last for the current session.

For the ongoing double-click investigation, ~/Library/Application Support/Explorer/input.log records version/PID, root mouse-down events, row activation decisions, paths opened, navigation, and errors. It rotates at 128 KiB into input.previous.log, stays local, and is disabled in tests. If opening still fails, the log distinguishes missing platform events, row dispatch, and filesystem failures.

Project structure

  • src/app.rs: GPUI workspace/panes, navigation, queues/conflicts, layout controls, batch preview, menus, and event routing.
  • src/search.rs, src/batch.rs, src/compare.rs, src/watch.rs: bounded structured search, exclusive rename plans, read-only byte comparison, and macOS directory notifications.
  • src/recovery.rs, src/recovery_window.rs, src/json_tools.rs, src/tools_window.rs: private editor recovery, recovery review, lossless JSON formatting/validation, and comparison windows.
  • src/features_tests.rs: isolated feature and recovery regressions.
  • src/input.rs, src/text.rs: native text input and Unicode range handling.
  • src/interaction.rs: native/synthetic click activation and pointer/drag regression tests.
  • src/fs.rs: dependency-free filesystem engine and unit tests.
  • src/jobs.rs: background operations and undo bookkeeping.
  • src/trash.rs: scoped restore/permanent deletion, mounted-volume Trash listing, and persistent original-location history.
  • src/native.rs, native/macos.m: macOS integrations and file clipboard bridge.
  • src/media.rs, native/media.m: media classification and native image, AVKit video, and PDFKit viewer windows.
  • src/editor.rs, src/editor_window.rs, src/editor_quit.rs: Rust text/code classification, strict encodings, multiline editing/undo, atomic saves, GPUI editor windows, and unsaved-quit review.
  • src/session.rs: bounded, atomic preferences storage, including non-UTF-8 paths.
  • src/icons.rs: embedded SVG icon assets.
  • tests/operations.rs: native filesystem integration tests.
  • tests/jobs.rs: isolated transfer retry and Trash worker regressions.
  • tests/gpui/: rendered GPUI event regression suite, including native quit-state simulation, save/cancel/retry, multiple editors, busy-window closure, and blocked-worker release.
  • .github/workflows/macos.yml: macOS checks, tests, and a downloadable app archive.

GitHub

The requested destination is kingbotss/explorer-gpu.

To publish from a Terminal with GitHub authentication and network access:

./scripts/publish.sh

The script clones existing remote history into a temporary checkout, overlays the source, commits changes, and pushes the checked-out branch. It never force-pushes or needs to write .git inside this source workspace. Generated binaries, build caches, and offline test adapters are excluded.

GPUI API reference: gpui 0.2.2.

About

Explorer is a native Rust + GPUI file manager for macOS with a Windows Explorer-style interface. It includes tabs, dual panes, built-in viewers and text editing, Trash management, and recursive duplicate detection by name, SHA-256, or both.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages