File operations
Copy, move and create
Section titled “Copy, move and create”Use Ctrl+C or Ctrl+X for the selection and Ctrl+V in the destination folder. Paste is also available from context menus, including List view. Clipboard transfers and drag/drop work between Luciole windows; the same transport supports other file managers.
Drop files on a folder or the destination pane. Ctrl requests Copy, Shift requests Move and Alt offers an action chooser. Alt-drop offers Create Link Here for native locations and within the same mounted SFTP server/account. These are symbolic links, not copies of the source data. Cross-server links and SMB/WebDAV link creation are unavailable. Server-side symlink support is checked before an existing destination is replaced. Dragging a folder into Places pins it instead of transferring its contents.
Archive entries can also be dragged from compatible applications. An ordinary file-list offer uses the normal Copy workflow after the source prepares its files. A KDE deferred-extraction offer requests extraction directly into a local folder, including mounted folders with a native path. The source application handles passwords, progress and existing-name decisions. Luciole reports that extraction was requested; that message does not mean extraction has finished. Review or cancel that extraction in the source application. These source-owned extractions do not enter Luciole’s File Operations or Undo history. Keep the source application open until it finishes.
A source may need time to prepare the files after a drop. Luciole waits asynchronously for a file list for up to two minutes and reports a read error if it cannot obtain a complete valid list. Normal file-list transfers then use Luciole’s progress and conflict handling. The source must provide usable files and keep them available through transfer completion.
There is no per-archiver drag preference: compatible producers are detected automatically. An external archive program may need its own extraction helpers. Luciole’s built-in Compress/Extract actions do not use a preferred external archiver; Open With can still open an archive in an installed application.
Deferred extraction cannot target a provider URI or pin an archive entry in Places. X11 Direct Save-only and arbitrary raw-data offers are not supported. Supporting one export protocol does not imply support for every archive application’s drag behavior.
When names collide, the conflict dialog offers Replace, Skip and a numbered new name. Folder copies can merge into existing folders. Apply-to-all choices are scoped to the current job. Failed-item retries are explicit. Cancellation stops remaining work; it does not undo already completed changes. Supported native copies, links and moves, remote copies and SFTP link transfers have Undo/Redo; interrupted-job recovery remains pending.
The background menu provides New Folder (Ctrl+Shift+N) and New Document. New Document offers an empty file (Ctrl+Alt+N) and files from the configured XDG Templates folder. Create Link on a single native item creates a symbolic or hard link where supported.
F2 renames one item. Multiple selected native items from the same containing folder open batch rename. Preview the proposed names before applying them.
File operations popover
Section titled “File operations popover”Open File Operations from the toolbar or main menu to see jobs across tabs and windows in this running Luciole process. It shows preparation, transferred bytes, known item totals, pending decisions and results. Work with no known final total uses a spinner rather than a percentage. Pause is not offered because the current services cannot pause.
Cancel stops remaining work; completed effects remain. Closing the popover does not cancel accepted jobs. It dismisses when the window resizes; open it again from the toolbar at the new size. Review returns to the page handling a pending decision. Details shows a bounded report with Copy report. Retry failed is offered only while that transfer’s retry information is available, and rechecks captured inputs without repeating completed items. Retried cut moves preserve the existing clipboard ownership checks.
The most recent 12 results stay in memory until Clear finished or application exit. Clearing results does not cancel running jobs. Older reports can outlive their service, so Retry may no longer be available. This is progress and reporting, not a persistent recovery journal. Separate Luciole processes have separate job lists.
Undo and redo
Section titled “Undo and redo”Undo (Ctrl+Z) reverses the most recent supported creation, rename, copy or move. Redo (Ctrl+Shift+Z) reapplies it. The main menu and folder background menu name the action, such as Undo Create Folder, Undo Batch Rename, Undo Copy, Undo Create Links or Undo Move. A fully completed batch rename or supported move selection is one action. The one-operation history is shared by tabs and windows in the same running Luciole process; it does not survive restart or cross independent processes. Text inputs retain their own text undo/redo.
Undo creation removes the unchanged new folder, empty file, template document or link from its containing folder. It does not send it to Trash. Changed, replaced or missing items are refused, and folders must still be empty. Creation Undo never traverses or deletes folder contents. Undoing a link removes only the new link. Redo uses the original created content, so changing or removing a document template does not change the restored document. Hard-link Redo requires its retained target to remain available and unchanged.
An unrelated occupant blocks reversal; move it aside before retrying. Reversal checks containing-folder and item identities/revisions. Reading a file does not invalidate the record. Batch replay checks all affected items and destinations before changing names and handles swaps and cycles. Entries whose names did not change are excluded.
Undo Move returns files, folders and links to their original containing folders. Redo returns them to the actual destination names, including numbered names chosen with Keep Both. A fully completed same-filesystem native selection is one action, including supported replacements and folder merges; skipped roots are excluded. Reversal checks all captured items and return names first. An unrelated occupant blocks reversal without being overwritten. Unsupported cross-filesystem/provider move shapes, partial and retried jobs do not supply move history. Large selections, unreadable snapshots or insufficient descriptor headroom can also leave a successful move without Undo.
Completed native moves between different filesystems can also supply one Undo Move action for independent files, whole folders and folder merges, including replacements and numbered names. A supported selection may combine these copy/remove moves with native renames. This also covers bind mounts where both locations report the same device but the kernel refuses renaming across the mount boundary. The source is removed normally after the destination is durable, freeing its space. Undo copies the verified destination back to the original folder, makes that copy durable, then removes the moved destination or restores its retained predecessor. Redo republishes the retained destination before removing the restored source. This copy-back does not restore original source inode identities or hard-link relationships. Source and destination names, containing folders and recorded contents must still validate; an unrelated occupant is never replaced.
For a folder merge, Undo restores emptied source directories before returning their moved children. Existing destination folders and unrelated contents stay in place, including files added there after the move. Redo requires the restored source trees to remain unchanged; adding a source child blocks the whole action before anything moves. Empty source directories retain their original identities; copied-back files have new identities.
This native cross-filesystem history also covers a parent folder renamed into place before later copied children are merged into it in the same job. Undo returns the copied children first, then returns the native parent with its original contents. Redo places the parent first, then reapplies the copied children. Nested native parents and an initially replaced destination folder are supported. The native parent, its original members and retained overwritten items keep their original inode identities; copied-back sources receive new identities. A later change anywhere in the recorded combined parent blocks the whole action.
Copied parents followed by later child merges, repeated mixed destinations, later ancestor replacements within mixed selections, partial jobs and retries remain outside this history scope. Undo needs enough free space and write access on the original filesystem. Cancellation or failure after publication can leave restored sources alongside destination items; File Operations reports partial effects and inspection paths, and no inverse is offered for an incomplete replay. These copies run as worker jobs through the existing global Undo/Redo actions.
Completed new-name, whole-item replacement and folder-merge moves within the same mounted SFTP server, account and port can also supply Undo Move and Redo Move, including folders, links and numbered names. Undo returns the verified moved data to the original containing folder and restores any retained previous destination; Redo moves it back. Unrelated occupants are refused. New-name and whole-item replacements retain the existing copy-then-remove transport behavior, so their history does not restore original server inode identities, hard-link relationships or metadata the provider did not preserve. Changed files, return folders, private markers or retained versions invalidate history. Overlapping move paths are not covered.
SFTP Move history uses owner-only private marker folders beside the original source and the destination. A merge additionally binds the existing destination folder with a private marker inside it. An overwritten destination remains in the destination history folder until needed. The source marker binds the return folder even when server identity metadata is limited. The record is optional: it requires private-folder support, at most 128 selected roots and 128 combined changed subtrees/original merge roots, 16384 captured entries, 64 levels and 256 MiB across the initial original/staged/replaced content proofs. Failed capture leaves the normal move available without Undo. Discarding valid history or clean exit removes verified private storage; uncertain or incomplete reversal preserves it with inspection paths. There is no automatic rollback or crash recovery.
A supported SFTP move merge first copies the changed children, then retains the whole verified original source tree privately on that server. Undo restores that original tree and reverses only the recorded destination changes, including replaced files. Existing destination folders, destination-only files and later sibling additions stay in place. Redo checks the restored source tree, retains it again and republishes the changed children. Empty merges are included. The retained original and any displaced destinations continue using server space while history is available.
In this retained-source merge path, if copying is skipped, cancelled or fails before source retirement, the original source remains and completed destination children are reported as copies. There is no partial-job Undo; an explicit supported retry can finish the move but does not create history. An unconfirmed server reply can leave the source in private storage instead: the error reports paths to inspect, and Luciole preserves the data. Changes to the original source after Undo or to recorded destination items block replay.
For a native move replacement, Undo returns the incoming item to its source and restores the actual previous destination. Redo retains that previous destination again and moves the incoming item back. The previous version must remain unchanged, including its complete folder contents. Plain moved folders travel with their contents without traversal or deletion; nested edits travel with that folder when its root revision remains unchanged.
For a native move-folder merge, Undo restores the original source-folder inodes and returns only the transferred children, including children whose previous destinations were replaced. Destination-only files and later sibling additions stay in place. Empty merged source folders are retained privately until Undo restores them; even an empty move merge can be undone. Redo validates the restored source trees and refuses edited or added children before moving anything. It retains each source container only after its recorded children leave and it is empty. Existing destination folders remain, and normal directory modification times can change.
Undo Copy removes the unchanged copied destinations from view, leaving the originals untouched. Undo Create Links removes only the new symbolic links. A completed native copy/link selection is one action, including numbered Keep Both names, folders, hidden children and dangling links. Completed native copy merges and supported replacements participate in that action; partial or retried jobs and unsupported remote effects do not supply history. The recorded tree must remain unchanged; edits, new children, replaced items or changed containing folders are refused before any root is moved. This check includes files nested inside copied folders.
Copies from mounted SFTP, SMB or WebDAV locations into native folders can also supply one Undo Copy action, including replacements, merges and numbered names. Redo republishes the retained local data without reading the remote source again, so a disconnected or changed server does not affect that replay. The same local revision checks, history bounds and retention rules apply. Provider moves do not yet supply history.
Copies to mounted SFTP destinations can supply Undo/Redo for new files and folders, numbered Keep Both names and replacements. Undo moves the recorded copies into private server-side storage; Redo restores those same items without reading the original source. The server must be available. A disconnection before replay can be retried after remounting. Edited contents, changed history markers and occupied names block reversal.
SFTP link transfers also supply Undo Create Links and Redo Create Links. They share the same conflict choices, private server storage and content/identity checks. A link to a folder does not traverse or copy its contents, and links never merge folders. Redo restores the recorded link even if its source disappeared; the restored link is then dangling. Existing destinations are restored by Undo when supported replacement history was captured. Links must remain within the same SFTP host, account and port. Ordinary provider refusal or optional history limits can leave a link transfer without history.
For SFTP Replace, Undo restores the previous destination and Redo restores the copied version, including whole-folder replacements. Both versions must remain unchanged. Reversal uses separate server renames, so the name can briefly disappear. If the connection is lost after a rename or reversal stops partway through, Luciole preserves remaining data and reports inspection paths instead of offering further replay. It does not automatically roll back completed effects.
SFTP folder merges can also supply one Undo Copy action for transferred children, including nested merges, replacements and numbered names. Undo restores replaced items and removes copied additions; the existing containing folders, skipped items and unrelated contents stay in place. Unrelated sibling additions do not prevent replay, but changed copied items or containing folders do. Redo uses the retained server-side data even when the original sources are gone. Empty merges and merges that skip every item do not create an Undo action.
Copies to mounted SMB and WebDAV destinations also support Undo/Redo for new names, replacements, numbered names and folder merges. These servers do not offer portable Unix permission controls, so Luciole keeps retained copies in an owner-only local temporary directory instead of a shared server folder. Undo removes unchanged copied entries and restores retained predecessors; Redo republishes retained data without the original source. Existing merge folders, skipped items and unrelated contents stay in place. The server must be available. Restoration uses ordinary copies, so server file identities and permissions follow the backend’s copy behavior.
Remote Copy history is limited to 128 changed subtree roots (individual children in an existing merge folder count separately), 16384 entries, 64 folder levels and 256 MiB of regular-file contents across the selection, counting both versions of replacements. Checking contents requires additional reads from the server. Over-limit copies still complete without Undo. Overlapping recorded destinations, including conservative SMB case aliases, partial jobs and retries do not supply this history. Private .luciole-history-* folders remain on the SFTP server or in the client temporary directory for SMB/WebDAV while history is available. SMB/WebDAV capture needs local space and additional provider reads; the same content budget counts both replacement versions. Discarding history or exiting removes only verified owned data; failed cleanup preserves remaining data and reports its location. Do not delete these folders blindly. No history survives a Luciole restart.
Replacing a destination during Copy or a symbolic-link transfer can also be undone. Undo restores the actual previous file, folder or link; Redo restores the incoming version. Both versions must remain unchanged, including folder contents. Replay exchanges only the recorded versions, so an unrelated replacement at that name is refused. Reading either version does not invalidate history. Previous files and links with hard-link aliases are supported, including aliases nested inside previous folders. Undo restores those same links. Luciole never searches for or writes to outside aliases. Edits or changes to their permissions/link counts invalidate history; normal removal of Luciole-owned retained links preserves the remaining aliases and their data. Unsupported types and unreadable/over-budget trees can still leave ordinary Replace without Undo.
When several sources replace the exact same destination in one job, Copy/Create Links Undo restores the original destination, or leaves that name vacant if none existed. Redo returns the final result. Intermediate copies are verified and discarded on a worker because their sources remain intact. Move Undo also returns every displaced incoming version to its own source; Redo retains those intermediate versions privately and restores the final destination. These repeated destinations remain one history action, including matching leaves merged into an existing destination folder. Intervening edits or occupied return names are checked before reversal.
Native Copy can also undo a newly copied folder together with later sources merged into it in the same job. Undo removes the combined result, restoring the initial destination if the first copy replaced one; Redo returns the same combined tree. Every source remains untouched. This includes nested merges, added folders and repeated child replacements. The whole combined tree must remain unchanged: a later added file inside it blocks Undo rather than being removed. For an already existing merge folder, the independent-child behavior below still applies.
Native Copy also supports replacing a parent folder after earlier copies went into it during the same job. Undo restores that parent’s original contents, removing those earlier copies and restoring any children they replaced. Redo returns the final replacement. Existing parent and child inodes, hard links and untouched contents are preserved; every copy source stays untouched. Luciole reconstructs the original parent only in its private retained storage, with bounded identity/content checks. If that reconstruction cannot finish, Undo stays unavailable and retained versions have inspection paths in File Operations. Later edits to either recorded version block reversal.
Native Move supports the same parent-before-child workflow. Undo first returns later merged children and restores their original source folders, then returns the initial moved folder with its own original contents. Redo moves that folder back before replaying the merged children. Original source-folder and file inodes are preserved. Changed contents or occupied return names are checked for the whole action before anything moves. For these dependent moves, the recorded source and result trees must remain unchanged; ordinary whole-folder moves still travel without a recursive history scan.
Native Move can undo a later parent replacement after earlier files or folders moved into that parent in the same job. Undo restores displaced parents before returning their moved children, preserving every source’s original folder and file inodes. Redo repeats the original move order and retains the overwritten versions again. This includes existing destinations, newly moved parents, nested replacements and several versions at the same path. It remains one Undo Move action across tabs and windows. The complete recorded source/result and retained trees must remain unchanged; an occupied return name blocks the action before anything moves. Cancellation can leave completed effects: inspect File Operations for retained versions and their paths.
The mixed-selection support described above requires the initial parent to have moved by native rename. A parent copied across a filesystem or mount boundary before later child merges does not yet supply Move history. Repeated mixed destinations and later mixed ancestor replacements also remain unsupported. Jobs exceeding the supported history bounds can complete without Undo; final-capture failures preserve displaced versions with inspection paths.
For copy-folder merges, Undo reverses only the transferred children and restores any replaced children. Destination-only entries and later sibling additions remain. Existing merge folders are kept rather than replaced; normal filesystem modification times can change as entries are added or removed. An empty merge alone creates no history record. Move merges additionally restore their emptied source containers as described above.
Inactive versions are retained in owner-only .luciole-create-* folders beside their destinations: previous destinations while Undo is available, incoming copies while Redo is available. Copy/link replacements use private folders at the job destination, outside any newly copied ancestor. Move replacements and emptied merge-source containers use the job destination or a same-filesystem mounted branch, outside newly moved ancestors; repeated Move replacements retain displaced incoming versions for return to their sources. For Copy, Redo returns the retained items without recopying from the original source, even if that original changed or disappeared. Cross-filesystem Move Redo also republishes retained destination data, but its restored source must still exist and match the recorded revision before removal. Unrecorded occupants are refused; copy/link replacement replay exchanges its two verified versions, while move replay restores the source and previous destination separately. Retention continues using the copied items’ disk space; discarding history or clean exit removes only verified owned data on a worker. Incomplete reversal or changed retained contents preserve the remaining items for inspection, with paths in the operation/cleanup reports. Do not treat these private folders as regenerable cache or delete their contents blindly. After a crash, history is unavailable and private retained items may need manual recovery; no automatic deletion/resume is performed.
Copy history is optional above 4096 changed roots, 16384 captured entries counting both replacement versions, 64 levels per stored subtree or available descriptor headroom. Move history counts both moved roots and merged source containers toward its 4096-effect cap; replacement snapshots and restored merge-tree capture are bounded too. The ordinary copy still completes when optional history cannot be captured. Unreadable copied folders can also prevent history capture. Derived original-parent manifests for Move ancestor replacements share a separate 16384-entry limit. A job’s shared inode-revision tracking is capped at 32768 identities. Ordinary selection never starts a history traversal; capture and validation run only for accepted jobs.
Starting another mutating file job clears the previous history, including redo. Preparation-only dialogs and browsing do not clear it. A successful supported operation supplies a replacement record when its history can be captured; a no-op rename supplies none. History is unavailable while file jobs run. Partial operations do not arm history. Cancellation or an intervening filesystem change during replay can leave completed effects or retained items needing attention: inspect the File Operations report. Incomplete replay retires history when its captured proof is no longer valid.
An undone created document’s original data can continue using disk space while its Redo record is retained. Clearing that history or exiting releases it. Trash, permission changes, unsupported transfer effects and a persistent recovery journal remain outside the current Undo/Redo support.
Delete moves native selections to Trash. A failed trash operation does not silently become permanent deletion. The full Trash interface requires the system’s GIO/GVfs provider and a session D-Bus connection, including browsing, restoration and Empty Trash. See the required Trash runtime for packaging requirements.
In Trash, Restore returns selected items to their recorded original locations and asks about conflicts. Delete Permanently removes selected trashed items after confirmation. Empty Trash is available from the Trash sidebar row’s context menu and by right-clicking the Trash folder background. It stays disabled when Trash is empty or unavailable; the sidebar briefly checks the provider when its menu opens. Hidden contents still count. Its confirmation includes the measured contents and size. Cancel starts with its normal appearance; Enter cancels until you explicitly focus another control. Permanent deletion is irreversible.
Archives
Section titled “Archives”Compress creates ZIP, TAR and 7z archives for native selections. Supported compressed TAR variants depend on the installed libarchive build and include gzip, bzip2, XZ and Zstandard. Browse Archive opens a read-only archive page; Extract Here and Extract To publish extracted contents through the normal transfer/conflict flow. Archive browsing can extract selected members or open an individual file through its associated application.
ZIP/TAR/7z/RAR input depends on available archive capabilities. Encrypted 7z input additionally uses a system 7-Zip executable. Passwords are requested when needed and are not stored in settings. Encrypted RAR is not supported. Numbered byte-split ZIP sets use name.zip.001, .002 and so on; select .001, with all contiguous parts beside it. Spanned .z01 sets and split-archive creation are not supported.
Opening and extracting archives validate members and enforce resource limits. An archive rejected as unsafe or unsupported is reported; Luciole does not silently disable these checks. Native archives are the current scope.
Properties and permissions
Section titled “Properties and permissions”Properties (Alt+Return) shows available file/media facts. Images can include pixel dimensions, videos can include codecs and duration, and PDFs can include page information. Installed providers determine which facts are available.
For folders, Properties starts a separate cancellable recursive count/size calculation. Ordinary selection and the side preview do not traverse folders to calculate totals. Recursive totals are currently unavailable for non-native locations and Trash.
Native permission and ownership editing is available in Properties. Multiple selections support bulk changes; recursive changes are explicit operations. Advanced permissions opens the POSIX ACL editor on supported native filesystems. Merely selecting a folder does not apply anything recursively. Luciole reports unsupported or denied changes rather than claiming they succeeded.
Network locations
Section titled “Network locations”Mounted, authenticated SFTP, SMB and WebDAV locations support the verified copy/move paths through installed GIO/GVfs backends. Some providers cannot preserve native symlinks, raw filename bytes or every metadata field. Read-only targets, conflicts, disconnects and partial moves remain explicit outcomes. Luciole does not provide its own server connection or credentials dialog yet.
See runtime providers for provider packaging requirements.