DEV Community: Artur

Carelo: A Modern Dual-Pane File Manager for Linux

Artur — Sun, 24 May 2026 04:13:10 +0000

Moving from macOS to Linux is usually easier than people expect. The terminal is excellent, package managers are powerful, window managers are flexible, and most development workflows feel at home quickly.

Then you start looking for a file manager.

Not just a basic file browser. A real dual-pane file manager. Something that lets you compare folders, move files with confidence, work with remote storage, preview content, open a terminal when needed, and keep your hands on the keyboard. Something modern enough to feel like it belongs on a current desktop, but practical enough to handle daily work.

On macOS, ForkLift fills that role well for me. It is polished, fast, and built around the kind of workflows power users actually repeat every day. After using that kind of tool, switching to Linux can feel surprisingly rough. Linux has capable file managers, and some classic dual-pane tools are extremely powerful, but the choices often fall into two categories: beautiful single-pane desktop browsers, or older commander-style tools that prioritize capability over modern interaction design.

Carelo started from that gap.

The Problem

A dual-pane file manager is not just about showing two folders side by side. That is the easy part.

The real value is flow.

You want to keep a project folder on the left and a build output folder on the right. You want to copy assets from Downloads into a repo, inspect a PDF, rename a file, archive a folder, jump into a remote server, compare locations, and keep moving. You want drag and drop when it is faster, keyboard shortcuts when they are faster, and a preview panel when opening another app would break focus.

Linux has tools that cover pieces of this. Nautilus integrates well with GNOME. Dolphin is mature and feature-rich. Midnight Commander is still great in the terminal. Krusader is powerful. But if you are coming from a polished macOS dual-pane workflow, the overall experience can still feel fragmented.

Carelo is an attempt to build the file manager I wanted after moving from macOS to Linux: modern, local-first, dual-pane by default, and designed for everyday file work rather than nostalgia.

What Carelo Is

Carelo is a desktop file manager built with Tauri and Rust. It focuses on fast local file operations, dual-pane browsing, rich previews, remote storage, archives, and configurable tools.

The core idea is simple: keep the interface familiar, but make the workflow feel current.

Carelo is not trying to hide the filesystem or turn file management into a cloud dashboard. It is for people who know where their files live and want a better way to work with them.

Dual Panes, Tabs, and Views

Carelo starts with the dual-pane model because that is still the most efficient layout for many real tasks. Copying, moving, comparing, extracting, staging, and organizing files all benefit from seeing source and destination at the same time.

Each pane can have its own tabs, so you can keep multiple working locations open without losing context. The app also supports list, grid, and column views, making it possible to switch between dense file operations and more visual browsing depending on the folder.

The goal is not to force one workflow. It is to make common workflows cheap.

Preview Without Losing Context

One of the biggest workflow breaks in file management is opening files just to know what they are.

Carelo includes a preview panel for metadata and common media types. Images, audio, video, PDFs, and text-like content can be inspected without leaving the file manager. The preview panel also shows practical file details such as size, timestamps, owner, group, permissions, and path information.

This matters more than it sounds. When you are cleaning up downloads, checking exported assets, reviewing documents, or comparing similar files, preview speed directly affects how focused the work feels.

Search That Fits File Work

Carelo has two search modes.

Fuzzy file search helps jump to files and folders by name. It is built for quick navigation inside the current location and streams partial results while scanning. Content search looks inside files, supports plain text streaming, and can search extracted text from formats such as PDFs and Office-style documents where supported.

Both search paths are cancellable and report progress through the current work indicator. That matters on large folders and remote locations, where a search should never make the app feel stuck.

Remote Storage

A Linux file manager should not stop at the local disk.

Carelo supports remote volumes such as SFTP, FTP, SMB/CIFS, WebDAV, and S3-compatible storage through its remote storage layer. Remote locations appear in the sidebar, can be browsed in panes, and participate in normal file workflows where possible.

The goal is to make a remote server or NAS feel like part of the same working environment, without forcing every operation through a separate app.

Archives as Part of the Workflow

Archives are part of file management, not a separate chore.

Carelo supports browsing and extracting archives, along with archive creation for common formats including ZIP, TAR, TAR.GZ, TAR.ZST, and 7Z. Long-running archive operations show progress and can be cancelled.

That makes archives behave more like file operations and less like modal interruptions.

Custom Tools and Editor Integration

Power users always have their own tools.

Carelo includes configurable context-menu tools, so commands such as opening a path in an editor can be added without changing the app. Tool commands can use placeholders like the selected path, and availability can be scoped to files, folders, or specific extensions.

The point is not to guess everyone’s setup. It is to make the setup configurable enough that Carelo can fit into yours.

Why Not Just Use the Existing Tools?

You should, if they work for you.

Dolphin, Nautilus, Krusader, Double Commander, Midnight Commander, and others all have strengths. Carelo exists because none of them quite matched the experience I wanted after moving from ForkLift to Linux.

The missing piece was not one checkbox feature. It was the combination:

dual-pane browsing as the default workflow
modern interface and previews
remote storage in the same mental model as local files
archive operations with progress and cancellation
configurable external tools
fast fuzzy search and content search
enough keyboard and mouse support to move naturally between both

Carelo is built around that combination.

Who Carelo Is For

Carelo is for developers, designers, sysadmins, content workers, and Linux desktop users who spend real time moving through folders.

It is for people who want more than a simple file browser, but do not want to live entirely inside a terminal file manager.

It is for people who miss the feel of tools like ForkLift, but want something that fits a Linux-first workflow.

The Direction

Carelo is still evolving, and that is part of the point. File managers are deeply personal tools. The only way to make one good is to use it, hit the rough edges, and keep sanding them down.

The direction is clear:

keep local file operations fast and reliable
make remote storage feel first-class
improve previews and metadata
expand search and indexing without making the app heavy
keep power-user customization simple
preserve the dual-pane workflow as the center of the product

Linux deserves modern file management tools that are not just ports, clones, or nostalgia projects.

Carelo is one attempt to build that.

https://github.com/aheinze/Carelo

ScriptLite — a sandboxed ECMAScript subset interpreter for PHP (with optional C extension)

Artur — Sat, 07 Mar 2026 03:50:47 +0000

I've been working on Cockpit, a headless CMS, for a while now. One thing that kept coming up was the need for user-defined logic — computed fields, validation rules, content transformations, stuff like that. The kind of thing where you want your CMS users to write small snippets of logic without giving them the keys to the entire PHP runtime.

I looked at existing options. V8js is heavy and a pain to deploy. Lua doesn't feel right for a web-focused CMS where most users already know JavaScript. Expression languages are too limited once you need a loop or a callback. So I started building my own.

What began as a simple expression evaluator for Cockpit turned into a full ECMAScript subset interpreter: ScriptLite.

What it does

It runs JavaScript (ES5/ES6 subset) inside PHP. No filesystem access, no network, no eval, no require — scripts can only touch the data you explicitly pass in. Think of it as a sandbox where users write logic and you control exactly what they can see and do.

$engine = new ScriptLite\Engine();

// User-defined pricing rule stored in your database
$rule = '
    let total = items.reduce((sum, item) => sum + item.price * item.qty, 0);
    if (total > 100) total *= (1 - discount);
    Math.round(total * 100) / 100;
';

$result = $engine->eval($rule, [
    'items' => [
        ['price' => 29.99, 'qty' => 2],
        ['price' => 49.99, 'qty' => 1],
    ],
    'discount' => 0.1,
]);
// $result === 98.97

It supports the stuff people actually use day to day: arrow functions, destructuring, template literals, spread/rest, array methods (map, filter, reduce, ...), object methods, regex, try/catch, Math, JSON, Date, and more.

PHP interop

You can pass in PHP objects directly. Scripts can read properties, call methods, and mutations flow back to your PHP side:

$order = new Order(id: 42, status: 'pending');

$engine->eval('
    if (order.total() > 500) {
        order.applyDiscount(10);
        order.setStatus("vip");
    }
', ['order' => $order]);

// $order->status is now "vip"

You can also pass PHP closures as callable functions, so you control exactly what capabilities the script has:

$engine->eval('
    let users = fetchUsers();
    let active = users.filter(u => u.lastLogin > cutoff);
    active.map(u => u.email);
', [
    'fetchUsers' => fn() => $userRepository->findAll(),
    'cutoff' => strtotime('-30 days'),
]);

Three execution backends

This is the part that got a bit out of hand. I ended up building three backends:

Bytecode VM — compiles to bytecode, runs on a stack-based VM in pure PHP. Works everywhere, no dependencies.
PHP transpiler — translates the JavaScript to PHP source code that OPcache/JIT can optimize. About 40x faster than the VM. Good for hot paths.
C extension — a native bytecode VM with computed-goto dispatch. About 180x faster than the PHP VM. Because at some point I thought "how fast can this actually go" and couldn't stop.

The nice thing is that the API is the same regardless of backend. The engine picks the fastest available one automatically:

$engine = new Engine();       // uses C ext if loaded, else PHP VM
$engine = new Engine(false);  // force pure PHP

// Same code, same results, different speed
$result = $engine->eval('items.filter(x => x > 3)', ['items' => [1, 2, 3, 4, 5]]);

The transpiler path is interesting if you want near-native speed without a C extension:

// Transpile once, run many times with different data
$callback = $engine->getTranspiledCallback($script, ['data', 'config']);
$result = $callback(['data' => $batch1, 'config' => $cfg]);
$result = $callback(['data' => $batch2, 'config' => $cfg]);

Possible use cases

User-defined formulas — let users write price * quantity * (1 - discount) in a CMS, form builder, or spreadsheet-like app
Validation rules — store rules like value.length > 0 && value.length <= 280 in your database and evaluate them at runtime
Computed fields — derive a field's value from other fields using a JS expression
Content transformation — map, filter, reshape API payloads or database rows with user-supplied logic
Workflow / automation rules — evaluate conditions and trigger actions defined by end users
Feature flags & A/B rules — express targeting logic as scripts instead of hardcoded PHP
Conditional UI — show/hide elements based on expressions like status === "draft" && role === "editor"

It's a standalone library with no framework dependency. composer require aheinze/scriptlite and you're good.

Some numbers

Benchmarked on PHP 8.4 with 10 different workloads (fibonacci, quicksort, sieve, closures, tree traversal, matrix math, etc.):

Backend	Total time	vs PHP VM
PHP VM	2608 ms	1x
Transpiler	66 ms	40x faster
C Extension	14.6 ms	178x faster

The transpiler gets within 3-4x of native PHP, which is honestly good enough for most use cases. The C extension is there for when you want to go full send.

Install

composer require aheinze/scriptlite

For the C extension:

pie install aheinze/scriptlite-ext

Repo: https://github.com/aheinze/ScriptLite

909 tests across all backends. MIT licensed. PHP 8.3+.

Would love to hear what you think, especially if you've run into similar "I need users to write logic but not PHP" situations. What did you end up doing?