filex — self-hosted file manager that embeds anywhere

A single Go binary with a full-featured web UI, pluggable storage/auth/DB drivers, real-time collaboration, an embeddable web component, a desktop app with background folder sync, and a built-in MCP server so AI agents can drive it natively.

Try it now

Live demo: demo.filex.sh — sign in with demo@demo.com / demo (admin role, sandbox resets nightly). Or run your own:

docker run -p 5212:5212 \
  -e FILEX_DEFAULT_STORAGE_DRIVER=local -e FILEX_DEFAULT_STORAGE_PATH=/srv/files \
  -v filex-data:/data -v "$PWD:/srv/files" \
  ghcr.io/brf-tech/filex:latest

That serves the folder you ran it in — open the UI and your files are already there. /data is filex's own directory (SQLite database, search index, thumbnail cache), which is why it is a named volume and not the folder you drop files into; the two are separate on purpose. Point $PWD somewhere else, or add more storages from the admin panel later.

The container runs as root by default, so what it writes into /data is root-owned; set PUID/PGID to run it as yourself (docs/DOCKER.md).

Open http://localhost:5212/admin — the first run prints admin credentials and embed instructions to the console. That URL is the operator's; the people you give accounts to get http://localhost:5212/drive, the same file manager without the panel around it.

Prefer a window over a browser tab? The desktop app (Windows / Linux / macOS) signs in to any filex server and syncs folders in the background — and on every platform there is a copy that runs without being installed (a portable .exe, an AppImage, a .zip): latest release · docs/DESKTOP.md.

Why filex

Most self-hosted file managers are either too small (a directory listing with uploads) or too big (a groupware suite you deploy for the file tab). filex aims at the gap:

• A browser client for your users, not just for you — hand someone a user or viewer account and …/drive and they get the file manager itself: their storages, uploads, sharing, search, the editor. No admin panel to walk through, no separate frontend to deploy. …/admin is the operator's door to the same app.
• Navigation people already know — a left panel with a prominent + New menu and Home · My files · Shared with me · Recent · Starred · Trash, plus the storages you can reach; a storage someone shared with you simply appears there, one click, no mount instructions. Anyone can collapse it to an icon rail from the top bar. Home is a view in the app, not a page beside it — your drives, what you opened last and what you starred, under the same sidebar and the same header as the files. This is the shell everybody gets: a single search field across the header with its ⌘K palette hint, a Type / People / Modified / Size filter row, Folders and Files as labelled sections, Details and Activity in the info panel, and a storage line. For people who want a file drive rather than a file manager, uiProfile: 'simple' presets the rest of the chrome off — one pane, one folder, list or grid. One explorer in every case: there is no second UI to keep in step.
• Embeds anywhere — the same UI ships as a Vue 3 component, a React component and a framework-agnostic <filex-explorer> web component. Put a real file manager inside your product, backed by your own filex server and locked to a per-tenant folder. The navigation panel comes with it — <filex-explorer sidenav ui-profile="simple"> is the whole opt-in for a host page that never touches JavaScript.
• AI-agent-native — a token-scoped REST surface (/api/ai) plus a native MCP server (/api/ai/mcp). Hand an agent a token confined to one folder and it can list, read, write, share and zip — nothing else.
• Real-time — presence avatars (a profile picture set once on the account, shown for every client signed in as you) and live file updates over WebSocket, in the native UI and in embedded contexts (short-lived ticket auth, API-polling fallback). A batch job is coalesced on the way out, so extracting a five-thousand-file archive costs an open explorer a bounded trickle of frames rather than five thousand (docs/REALTIME.md).
• On your desktop too — the same explorer ships as a Windows/Linux/macOS app that keeps local folders in step with the server from the tray, updates itself, and holds several accounts (or tenants) side by side. Right-click a folder → Keep on this computer and it mirrors under one filex folder; everything else stays online-only in the window. Headless machines get the same engine as filex sync / filex client.
• Speaks the protocols both ways — filex can connect to local disks, S3, FTP, SFTP, WebDAV and SMB/NAS shares, and it can be reached as S3, SFTP, FTPS, NFSv3 and WebDAV. Point rclone, restic, aws s3, WinSCP, FileZilla, a scanner that only learned FTP or a media player that only learned NFS at filex, and they land in the same tree, with the same permissions, the same trash and the same quota as the web UI. Off-LAN there is also filex mount, which attaches a remote server over ordinary HTTPS — a folder on Linux, a drive letter on Windows (docs/PROTOCOLS.md).
• Multi-tenant by design — storage-per-tenant with native tenancy mode, RBAC roles + per-item grants, confined API tokens, per-token identities for audit trails, and app-vs-user token kinds so a shared embed credential cannot manage anybody's keys. The tenant boundary is enforced on every route that names a row, not only on the ones that list them, and instance-wide settings are reserved to the supertenant.
• Boringly deployable — one binary or one container; SQLite by default, Postgres/MySQL when you want them; every driver switched by env vars. All three engines are migrated, compared against each other and written to by CI on every change, because "supported" used to mean "compiles" (docs/DATABASES.md).

┌─────────────────────────────────────────────────────────────┐
│  filex (Go binary; 43 MB slim / 511 MB w/ thumbnails)       │
├─────────────────────────────────────────────────────────────┤
│  HTTP API (chi)  │  Admin UI (Vue 3, embedded)              │
│  Auth Drivers:   │  local · oidc · ldap · proxy-header      │
│  Storage Drivers:│  local · s3 · ftp · sftp · webdav · smb  │
│  Served as:      │  s3 · sftp · ftps · nfs · webdav         │
│  DB Drivers:     │  sqlite (default) · mysql · postgres     │
│  Queue Drivers:  │  follows the DB · redis                  │
│  Realtime:       │  WebSocket presence + live updates       │
│  RBAC:           │  roles + per-item grants + share invites │
│  AI / MCP:       │  /api/ai REST + native MCP server        │
│  Sync Worker:    │  etag / size+mtime diff + tombstone      │
│  Replica Layer:  │  primary→replica + rules + reconcile     │
│  Protection:     │  trash + versions + ClamAV (bin/clamd)   │
│  E2E folders:    │  client-side WebCrypto (server blind)    │
│  Notifications:  │  webhook + in-app bell + read/unread     │
│  Search:         │  Bleve (full-text, embedded)             │
│  Thumbnails:     │  image · video · pdf · office            │
│  Plug & Play:    │  OnlyOffice · Drawio · Mermaid           │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ HTTP API
       ┌──────────────────┼──────────────────┐
       │                  │                  │
   @brftech/         @brftech/          @brftech/
   filex-core        filex             filex-react
   (Vue 3 SFC)       (Web Component)   (React adapter)
       │                  │                  │
       ▼                  ▼                  ▼
   Vue 3 apps       Any framework      React apps
                    (vanilla, Angular,
                    Svelte, Solid, …)

   Same API, no server plugins:  desktop app (Electron, Windows/Linux/macOS)
                                 CLI client (filex client · filex sync)

Screenshots

Sharing — PIN, expiry, download limit, one-line curl	Markdown viewer

Admin panel	Demo landing

The shell — what everybody lands on	Searching this folder; ⌘K / Ctrl K hands the query to the palette

Navigation panel — Home, My files, Shared with me, Recent, Starred, Trash, and your storages	Collapsed to the icon rail

Shared with me — folders other people granted you, no mount instructions	Embedded in another product's page

How to connect — the guides, built from your deployment	API keys — mint your own, in the explorer or in an embed (a person's session or token; an embed proxied with one shared app token does not get this entry)

Reaching filex from anything — S3, SFTP, FTPS, NFS, WebDAV. Every command is built from your deployment

A storage filex does not ship — installed as a plugin, describing its own config form

Quick start — binary

# Download from https://github.com/BRF-Tech/filex/releases
./filex serve

═══════════════════════════════════════════════════════════════
  filex · self-hosted file manager
═══════════════════════════════════════════════════════════════
  Listening on:   http://0.0.0.0:5212
  Admin UI:       http://0.0.0.0:5212/admin
  Files UI:       http://0.0.0.0:5212/drive
  Embed JS:       http://0.0.0.0:5212/embed.js

  First run detected. Initial admin user created:
    Email:    admin@local
    Password: kT9_x4Pq2Nm-BvLs
  Saved to:  ~/.filex/.first-run.txt (mode 0600, shown ONCE)
  Change at: /admin/dashboard?settings=1
═══════════════════════════════════════════════════════════════

Self-host with Compose or Helm

The docker run above is enough to try filex out. For a real deployment, ready-made stacks live in deploy/:

• deploy/compose/ — Docker Compose:
  • minimal — filex + SQLite + local disk (one service, zero dependencies).
  • full — filex + PostgreSQL + Redis + Caddy (auto-HTTPS), plus toggleable add-ons: OnlyOffice, Drawio, universal converter, MinIO (S3). Turn each on/off with a Compose profile in .env.
• deploy/helm/filex/ — a Helm chart for Kubernetes (Deployment + PVC + optional Ingress). Every add-on above is an enabled toggle in values.yaml — bundle PostgreSQL / Redis / MinIO, or wire external OnlyOffice / Drawio / converter.

Step-by-step instructions for each tier are in docs/INSTALLATION.md.

Embed in your app

Vue 3

pnpm add @brftech/filex-core

<script setup>
import { FileExplorer } from '@brftech/filex-core';
import '@brftech/filex-core/style.css';
</script>
<template>
  <FileExplorer :config="{ apiBase: 'http://localhost:5212', auth: { kind: 'bearer', token: '…' } }" />
</template>

React

pnpm add @brftech/filex-react

import { FileManager } from '@brftech/filex-react';
<FileManager config={{ apiBase: 'http://localhost:5212' }} onError={(e) => console.error(e)} />

There is no stylesheet to import — the look travels inside the bundle and is injected on mount, so nothing is missing from that snippet. ⚠ A bundler will need the optional viewer packages externalized (monaco-editor and friends), which docs/INTEGRATION.md shows in one rollupOptions.external line; every one of those imports is guarded, so the viewers degrade rather than break.

Vanilla JS / any framework

<script type="module" src="https://cdn.jsdelivr.net/npm/@brftech/filex/dist/filex.js"></script>
<filex-explorer api-base="http://localhost:5212" sidenav connections ui-profile="simple"></filex-explorer>

sidenav turns the navigation panel on (it is on by default; the attribute is there so a host page can state it either way), connections adds its "How to connect" and "API keys" entries, and ui-profile="simple" presets the power-user chrome off. All three are ordinary config keys, so the Vue and React wrappers set them the same way — see docs/INTEGRATION.md.

Multi-tenant hosts typically proxy the API server-side, inject a confined token (root: tenant-folder) per request, and strip client headers — the sandbox is enforced by the backend, not the widget. Such a token is kind: "app", so the panel hides the surfaces that belong to one person — API keys, Recent, Starred, Shared with me — while Upload, the storages, Trash and "How to connect" stay. See docs/INTEGRATION.md and docs/MCP.md.

Desktop app & CLI

The explorer also ships as a Windows / Linux / macOS desktop app — the same component the web UI and the embeds render, not a separate half-copy:

• Several accounts at once — a rail of servers/tenants, each showing its own branding.
• Drag files out — drag a selection onto the desktop or into another app: folders and multi-selections arrive as separate real files and folders. Anything already kept on this computer drags instantly; the rest is fetched once and cached (docs/DESKTOP.md).
• Keep on this computer — right-click any folder, file or whole storage to mirror it under one filex folder on the machine (movable from Settings); everything else stays online-only, and every row says which it is (✓ ◐ ⟳ ☁). "Keep online only" hands the local copy back to the Trash, or leaves it (docs/DESKTOP.md).
• Folder sync — pair a local folder with a server folder and they stay in step both ways while the app sits in the tray: parallel transfers and listings, a first run that resumes where it was interrupted, 30-day local trash, and an engine that refuses to turn a missing folder into a mass delete (docs/SYNC.md).
• Opens Office documents off your own disk — double-click a .docx/.xlsx/.pptx (or any of the ten Office types) and it opens in the editor your server runs, on a machine with no Office installed. A document inside a folder you keep on this computer opens as itself; anything else is copied up, edited, and written back over the original (docs/DESKTOP.md).
• Signs in through your browser, so SSO and MFA behave exactly as they do on the web.
• Updates itself — downloads quietly, installs on quit; FILEX_NO_UPDATE=1 opts out.
• Runs without being installed, if that is what you need: the Windows portable .exe, the Linux AppImage and the macOS .zip all run from wherever you put them. The portable Windows copy keeps everything it has in one filex-data folder beside itself, so deleting that folder leaves nothing of yours on a machine that is not yours — the trade is that it does not update itself.

Installer, portable .exe, AppImage, .deb and .dmg are attached to the latest release — not code-signed yet, so expect a SmartScreen prompt on Windows. Details: docs/DESKTOP.md.

The same binary is also a client for servers, scripts and headless machines:

filex client login --url https://files.example.com
filex client upload build/report.pdf docs://ci-artifacts/

filex sync add ~/Documents/work docs://work   # the engine the desktop app uses
filex sync run --watch 30s

See docs/CLI.md and docs/SYNC.md.

AI agents / MCP

filex ships a token-authenticated automation surface at /api/ai (list, read, write, move, delete, search, share, zip) and speaks Model Context Protocol at /api/ai/mcp:

claude mcp add filex --transport http https://files.example.com/api/ai/mcp \
  --header "Authorization: Bearer <api-token>"

Tokens are scoped by verb (read,write,delete,share), optionally confined to a single folder, gated by the same RBAC grants as the UI, and stamped with per-token identities so audit logs, shares and presence show who (which integration) did what.

A large file already on the agent's disk never fits through a tool call — its bytes would have to travel through the model's context. Upload tickets fix that: one authorized call pins the destination and returns a short-lived, single-use URL that needs no credentials, so even an agent with no filex token can finish the transfer with curl -T bigfile <url>. Details: docs/MCP.md.

Features

• Multi-storage — mount many storages at once (local, S3, FTP, SFTP, WebDAV, SMB/NAS); each appears as a top-level folder. Each also carries an address that never moves: the storage's name is the first path segment on WebDAV, SFTP, NFS and the S3 API, so renaming one would re-address it — a mount written against its uid survives every rename. Copy or cut in one and paste in another: filex streams the tree between the two drivers, keeps each file's timestamp, and only removes the original once the copy is verified.
• Drag files out to your desktop — in the desktop app, drag a selection into Explorer/Finder or another program and it lands as separate real files and folders, not an archive; in a browser, a single file drags out the same way (docs/DESKTOP.md).
• Storage plugins — a storage filex has never heard of is a separate program you install from the admin panel: it describes its own config form, filex speaks a small HTTP/JSON protocol to it, and its driver then behaves like any built-in one. Any language; a Go SDK makes it three methods. filex probes every capability a plugin claims — at install, and again against the configuration you type when you save a storage on it — and refuses one that cannot do what it says, because a half-working driver produces failures that look like filex being broken. Upgrades replace the binary in place and roll back if the new one does not come up (docs/PLUGINS.md).
• Protocol gateway — the same tree is reachable as S3 (SigV4; aws-cli, rclone, restic, mc, s3fs), SFTP (OpenSSH, WinSCP, FileZilla, sshfs), FTPS (explicit TLS, for the equipment that only learned FTP; hand it your reverse proxy's auto-renewing certificate — it is re-read on change), NFSv3 (LAN NAS clients, media players) and WebDAV — each with its own credential you can revoke on its own, and all of them behind the same permissions, trash and quota as the UI (docs/PROTOCOLS.md).
• filex mount — attach a remote filex server to a folder over ordinary HTTPS: a folder on Linux, a drive letter on Windows (filex mount Z:, needs the free WinFsp). Not a sync: nothing is copied but a bounded read cache, so it opens one file out of a hundred thousand without downloading the rest.
• Real-time collaboration — presence bar with live avatars + focus, instant file-change updates over WebSocket, polling fallback. One write is announced the moment it lands; a burst (a zip extraction, a folder upload, an NFS client writing chunk after chunk) is merged into one frame per window so the folder stays live without flooding the page (docs/REALTIME.md).
• A listing that behaves like a table — resize a column, hide one, drag one to a new place; the table scrolls sideways rather than dropping a column when it runs out of room, and the actions column stays pinned to the right. Sort by name, type, date or size, in either direction, and the grid and the list obey the same sort — until this release "sorted by size" was a fact about one view, and switching views reordered the rows under you. Sorted by date, all three views group the rows under Today · Yesterday · This week · This month and then month by month, in your time zone rather than the browser's.
• A folder remembers how you left it — optional, from user settings: the view mode and the sort of each folder you actually set up, kept per person on the server so they follow you to another machine and to the desktop app, and never leak to anyone else looking at the same folder. Off by default, in which case your last choice simply applies everywhere (docs/INTEGRATION.md).
• Who owns a file — every node carries its owner, the listing has an Owner column and the filter row a People entry, and quota counts against the owner rather than whoever last touched the file.
• Take a selection with you — pick several files and folders and Download streams them as one archive, built on the fly: no temporary file is written into your storage, nothing is buffered in the tab, and a 700 MB archive costs the server under a megabyte of memory. Move to and Copy to open a folder chooser that spans every storage and refuses a destination you cannot write to — server-side, not just in the dialog.
• New document — create a Word, Excel, PowerPoint or OpenDocument file, or any text or code format, from the + New menu: name it, choose where it goes, and it opens in the editor that handles it. The templates are real, minimal, valid documents compiled into the binary, so this works on an install with no LibreOffice; a type this deployment could not then open is not offered in the first place, and the dialog says why.
• RBAC + item permissions — roles, per-file/folder grants with inheritance, share invites by e-mail (SMTP), grant-aware search and listings. Shared with me answers the reverse question from the recipient's side — what other people granted you, and which storages you reach only through a grant.
• The shell — one layout, for the operator and the end user alike, in the admin app, the desktop app and every embed: a top bar spanning the full width with the collapse control and the product mark at its left edge, one search field whose ⌘K / Ctrl+K chip hands the query to the command palette (the field searches this folder; the palette is where "everywhere", saved searches and commands live), a primary + New menu (upload files · new folder · new document · request files), a Type · People · Modified · Size filter row under the breadcrumb, Folders and Files as labelled sections in grid view, an info panel split into Details (with "People with access" and a share-link row) and Activity (version history and comments), and a storage line under the navigation. Theme, palette, language, density, the time zone, the start page and the notification switches all live in user settings, reached from the avatar; the keyboard editor and Restart the tour are in the same menu. Nothing is removed from the build — an embed, which has no settings dialog, keeps a "⋯" menu that still holds them (docs/INTEGRATION.md).
• Home, inside the shell — the landing view for everybody, admins included: your storages, what you opened last and what you starred, as cards in the content area with the same navigation panel and the same header as the files. Moving between Home and a folder changes the content and nothing else. An operator who would rather land on the admin dashboard chooses it in their profile settings.
• Navigation panel — the + New menu as the primary action, the destinations Home / My files / Shared with me / Recent / Starred / Trash, the storages you can see, and How to connect + API keys: the per-protocol guides and the self-service token manager, opened from inside the explorer so an embedded copy's users can mint the credential WebDAV/FTPS/filex mount ask for instead of asking an administrator. Collapsible to an icon rail (remembered per browser) from the top bar, a drawer instead of a column under 560px. On by default in the web app, the desktop app and every embed; uiProfile: 'simple' additionally turns off the tab strip, the split pane, the gallery view mode and the "How to connect" surface without removing any of them from the build (docs/INTEGRATION.md).
• Sharing — public links with PIN, expiry and max-downloads, under an admin-set maximum link life (default 7 days — the dialog only offers what the server will keep); folder links stream as ZIP (cached, pre-warmed up to a size ceiling, swept after a week); file-request upload links for inbound drops; ShareX-compatible upload endpoint (docs/SHARING.md).
• Desktop app + folder sync — Windows/Linux/macOS app: tray-resident two-way sync, selective sync (right-click → Keep on this computer, one root folder per account, the rest online-only), several accounts at once, opens Office documents from your own disk in the server's editor, self-updating (macOS: unsigned build, updates by re-download until it is signed). Each document opens in its own window (titled with the file's name), the windows are frameless with the app's own controls (native traffic lights on macOS), and Settings → Open files with chooses single- or double-click to open (docs/DESKTOP.md, docs/SYNC.md).
• Trash & version history — deletes are reversible within a retention window, writes keep snapshots; both live in the storage you already mounted (docs/TRASH-VERSIONING.md).
• Write protection — optional ClamAV scanning of every file written — the built-in editor included, and files the storage sync finds on the backend rather than through filex — reached through a local binary or a clamd container over the network; plus trash/version retention behind one admin surface. The switch, the scanner mode and address, the size ceiling and the editor save-scan window live on Settings → Protection; the FILEX_CLAMAV* variables seed them on a first boot and then step aside (the scanner's binary path stays environment-only, deliberately — it is a command this server executes) (docs/PROTECTION.md).
• E2E encrypted folders — client-side WebCrypto; the server stores ciphertext and never receives a key. Each folder gets a recovery key, shown once, so a forgotten password is not automatically lost data; an operator can optionally enable key escrow — at install, or adopted later on a running installation; it never reaches existing folders on its own, but their owners are offered the choice at unlock — and its use notifies the folder's owner (docs/E2E-ENCRYPTION.md).
• Native multi-tenancy — provider/tenant mode with per-tenant isolation on one instance (docs/MULTI-TENANCY.md).
• Driver-pluggable everything — storage / auth / DB / queue drivers opt-in via env (FILEX_AUTH_DRIVERS=local,oidc, FILEX_QUEUE_DRIVER=postgres, …).
• OIDC SSO-first — optional auto-redirect to your IdP with break-glass local login (?local=1), and the admin role follows an IdP group at every sign-in.
• LDAP / Active Directory — directory accounts sign in on the same password form as local ones, and on WebDAV/SFTP/FTPS/S3/NFS too; private-CA support, and local stays first so admin@local works while the directory is down (docs/LDAP.md).
• Replica + reconciliation — primary→replica fan-out (mirror / append-only / skip per path-glob rule), read fallback, scheduled status report, one-click "Fix all".
• Persistent op queue — restart-safe queue in your own database (SQLite / Postgres / MySQL) or in Redis, worker pool with retries + cancel + admin dashboard. Every driver orders by priority, so the antivirus scan for a file somebody just uploaded is served ahead of the twenty thousand a first import queued. Unset, the driver follows the database rather than defaulting to SQLite — pointing SQLite statements at a Postgres server is a syntax error on every poll and no job ever runs.
• DB-backed file tree — listings come from the DB cache (1-5 ms), not the storage backend (~100 ms); a periodic sync catches out-of-band changes, by etag where the backend reports one and by size + modification time where it does not.
• Viewers & editors — image/video/audio, PDF, Markdown (split editor + preview), CSV, code (Monaco), Office via OnlyOffice, Drawio + Mermaid diagrams, 3D models.
• Universal converter — optional side-car converts between document/image formats from the UI. It, OnlyOffice and drawio are configured in the admin panel and apply to the running server, with no restart (docs/ONLYOFFICE.md, docs/CONVERT-INTEGRATION.md).
• Notifications — generic JSON webhooks (Slack/Discord-agnostic): any number of targets, each with its own signing secret and its own per-event subscription, plus an in-app bell with read/unread and a per-user mute matrix. A write that creates a file and a write that replaces one are different events (file.uploaded / file.updated), and the ones an operator most wants on their own — an infected upload quarantined, a failed upload, an encrypted folder opened with its recovery key — are subscribable individually (docs/NOTIFICATIONS.md).
• Search — Bleve embedded, full-text + metadata, permission-aware. VS Code-style filename scoring: folders count and word order does not (main code finds Code/main.go), separators and typos forgiven (invoice 2026 finds invoice_2026.pdf, mian.go finds main.go) while numbers are matched literally (2026 never means 2025), tag: filters, exact matches ranked first.
• Thumbnails you can read — a PDF shows its first page, top-anchored so the title is in the card; a video its first frame that is not black (opening on a fade used to produce a black square, and a clip shorter than a second produced nothing at all while the row still said "ready"); an Office document its rendered first page; and a text, code or CSV file fills the card with its own first lines rather than repeating the extension the row already prints. image, video (ffmpeg), PDF (ghostscript), Office (libreoffice); capability-aware, and a server missing one of those binaries now says so in its log at boot instead of silently drawing coloured rectangles. A cached thumbnail is released when the file it belongs to is deleted for good, and a periodic reconciler reclaims the orphans an older install accumulated (docs/thumbnails.md).
• Tabs, themes & deep links — several folders open side by side, light/dark/auto theme, and an address bar that tracks the open folder so a pasted link lands there. Eight palettes ship in the theme gallery, each one a map of the --fe-* tokens rather than a second stylesheet, so a host page or an embed can pick one — or set its own values — without forking any CSS.
• Open the way each device expects — with a mouse, a single click selects and a double click opens (Enter opens the selection) — the classic file-manager gesture, and a per-viewer preference (ExplorerConfig.openTrigger, default 'double'; the desktop app exposes it as Settings → Open files with, and 'single' restores one-click open). On a touchscreen a tap always opens — there is no hover-to-select. On every device the checkbox is the one click or tap that selects (Shift extends the range) and a right click or long press opens the menu; list rows, grid cards and gallery tiles all carry it.
• Keyboard, and it says so — every verb in the right-click menu and the toolbar prints the key that runs it, read from the registry so it follows a remap. Thirty-two actions are remappable from Shortcut settings (stored per browser); the handful of combinations a browser takes for itself, like Ctrl+W, are refused with a reason instead of stored as a key that would never fire.
• Usage & cost — filex does not meter your provider's bill; it reads the report the provider already writes, normalises it and prices it with a table you can edit. Backblaze B2's daily CSVs are read over the same S3 API filex already speaks, so no new dependency and no new credential type. Free allowances are their own fields rather than constants in a formula, and the page keeps the provider's account-level row apart from its per-bucket rows — summing them counts the same transactions twice, by exactly the amount nobody notices (docs/USAGE.md).
• Audit log — every mutation recorded with actor, integration identity and metadata.
• CLI client — the same binary reaches a remote server (filex client, filex sync) with no server-side plugin (docs/CLI.md).
• Self-updating — patch releases install themselves, minor ones are announced for one-click upgrade (docs/UPDATES.md).
• Single binary — goreleaser matrix: linux/macOS/Windows × amd64/arm64. CGO=0, modernc.org/sqlite.
• i18n — English + Turkish out of the box, public pages included: a share link, a PIN gate or a file-request page renders in the visitor's language (?lang=, then Accept-Language, then the server default).

Architecture

See docs/ARCHITECTURE.md.

Documentation

Getting started — Installation · Configuration · Releases · Updates

Clients — Desktop app · Folder sync · CLI · Integration / embedding · AI & MCP

Without a browser — Protocols (S3 · SFTP · FTPS · NFS · WebDAV · filex mount) · WebDAV

Storage & access — Storage · Storage plugins · Usage & cost · Uploads & resume · Quotas · SSO (OIDC) · LDAP & proxy auth · RBAC & permissions · Multi-tenancy

Data & features — Sharing & file requests · ShareX · Trash & versioning · Protection · E2E encryption · Search · Realtime & presence · Notifications · Thumbnails · Replication

Operate & extend — Deployment · Docker · Metrics · Architecture · Backend API spec · Component API · OnlyOffice · Converter

Full documentation index

Development

git clone https://github.com/BRF-Tech/filex.git
cd filex
pnpm install
pnpm run build:all    # builds packages, web, then Go binary
./bin/filex serve

Subdirectories:

• backend/ — Go HTTP service (cmd/filex, internal/*, db/queries, db/migrations)
• packages/core — @brftech/filex-core (Vue 3 SFC, source of truth)
• packages/webcomponent — @brftech/filex (Web Component wrapper)
• packages/react — @brftech/filex-react (React adapter via @lit/react)
• web/ — Vue 3 admin UI (embedded into Go binary via go:embed)
• desktop/ — Electron app (bundled main process, tray sync, auto-update)
• demo/ — Standalone HTML demos for each framework
• e2e/ — Playwright suites (web, embeds, packaged desktop app) + shots/, the script that retakes the screenshots above
• docker/ — Dockerfiles + compose
• deploy/ — ready-made Compose stacks + Helm chart (see deploy/)
• docs/ — Markdown documentation
• docs-site/ — VitePress site published at docs.filex.sh

Contributions welcome — see docs/CONTRIBUTING.md.

License

MIT — see LICENSE.