KimtFS

Freev1.6.0

Save folders, files and uploads privately on your device

Overview

KimtFS is a private, on-device file system for your browser. It gives you a familiar folder tree: create folders, write text files, and upload files of any type — and everything is stored locally. It is part of the kimtos new-tab app suite.

Everything is fully on-device. There is no backend, no account, and no network: every folder, file, and uploaded blob lives in your browser's storage and never leaves the machine.

Highlights

• Folders & files, fully on-device — a column list or an icon grid with Name, Size, Kind and Modified. Click a heading to sort by it; folders stay above files either way.
• Find things — a search that looks through the folder you are in and everything under it, and full keyboard navigation (arrows, Enter, Backspace, Delete).
• Drag and drop — drag items onto a folder to move them, or drop files in from your desktop.
• Text files — create a text file, or open an uploaded one, and edit it inline in the main pane; edits autosave a moment after you stop typing.
• Uploads of any type — upload one or many files; each keeps its original bytes, size, and MIME type. Every type renders: images, audio, video, PDFs, pretty-printed JSON, rendered Markdown and syntax-coloured code — and a hex dump for anything else. All of it can be downloaded back out.
• Archives — compress any file or folder to a .zip, or open one to see inside it and extract it. Done by the browser's own compressor, in the tab, with no library and no upload.
• Nothing leaves your browser — no servers, no analytics, no third-party calls.
• Delete with undo — deleting a file or a whole folder (and everything in it) is reversible for 6 seconds through an undo toast.
• AnubisDB integration — because all data is stored under the app's id prefix, KimtFS content is automatically listed and attributed in the suite's AnubisDB storage console.
• Agent tools (declared, not active) — KimtFS declares tools to list, create, read, update, rename, and delete folders and files, for a future on-device assistant. No shipped model can run them, so nothing touches your files today.

Privacy model

KimtFS writes only to local browser storage:

• Folders and files are records in the shared IndexedDB, linked into a tree by a parentId (an empty parentId means the item lives at the root).
• Text files keep their content inline with the file record.
• Uploaded files keep their bytes as a separate blob in the same local database, referenced by the file's id.

Nothing is uploaded, and there are no analytics or third-party calls. Your files travel with the browser profile and are included in the suite's local backup.

Getting Started

Open KimtFS from the dock. The window has two parts: a path bar across the top, and the explorer below it — which shows either a listing of the folder you are in (as columns or as a grid of icons), or a file you have opened.

Where am I, and where will my next file go?

The path bar answers both. It shows the trail from the root — KimtFS › Documents › Music — and every segment is clickable, so you can jump back up at any point. Next to it, in plain words, is where a new file, folder or upload will land: New items go to Music.

That target follows your selection: select a folder and new items go inside it; select a file and they land beside it, in the same folder; click KimtFS in the path bar and they go to the top level.

The column list

The main pane lists the folder you are in, with four columns:

Column	What it shows
Name	The item's name, with a folder or file icon
Size	The file's size on disk (folders show a dash)
Kind	What the file actually is — Image, PDF document, JSON, Markdown, Code, Audio, Video
Modified	A time for anything changed today, otherwise a date

Click a column heading to sort by it; click the same heading again to reverse it. Folders always stay above files, in every column and both directions.

• Single-click a row to select it.
• Double-click a folder to go into it, or a file to open it.
• The back arrow in the toolbar goes up one level.

The keyboard

Click the list once and you can drive it entirely from the keyboard:

Key	Does
Up / Down	Move through the rows
Enter	Open a file, or go into a folder
Backspace	Go up one level
Delete	Delete the row (with the same confirmation as everywhere else)

Search

The search box in the toolbar looks through the folder you are in and every folder underneath it — not just the rows on screen. Because a name on its own is ambiguous when three files are called report.txt, each result also shows the folder it lives in.

Working with items

• New file or folder — the ＋ button in the toolbar.
• Upload — the upload button takes one or more files from disk.
• Go into a folder — double-click it. A single click selects it, so the next new file lands inside without moving you.
• Go back up — click any segment of the path bar, or the back button.
• Select several at once — the Select button turns on tick-boxes. Tick a few (or drag across them) and delete them in one go, with a single undo.

Right-click anything for its menu: Get Info, Rename, Delete, plus New file / New folder / Upload here on a folder, and Open / Download on a file.

Get Info shows the kind, the size (or the number of items in a folder), where it lives, when it was last modified, and the file's type.

Drag and drop

• Drag a file or folder onto a folder to move it into it. Dropping onto a file means "into the folder that file is in".
• Drag it onto the path bar to move it back out — drop it on any segment and it lands in that folder, including KimtFS for the top level.
• Drag files in from your desktop and drop them on a folder or on the listing. The bytes go straight into this browser's storage. Nothing is uploaded anywhere, because there is nowhere to upload to.

Selecting several at once

Press Select above the listing to enter selection mode: tick the items you want (or press and drag across them), then Delete (N) removes them all with one confirmation and one undo. It works in the grid as well as the list.

Opening a file

KimtFS renders whatever you saved:

• Images, audio and video display or play inline.
• PDFs are rendered page by page, in the app.
• JSON is pretty-printed — and an invalid .json shows you the parse error, which is usually why you opened it.
• Markdown is rendered, and code is shown with syntax colouring — the same highlighter the suite uses for code inside a note, so a file looks the same wherever you read it.
• Anything else gets a hex dump of its first bytes, so you can at least see what it really is.

Any file whose content is text opens in an editor that autosaves shortly after you stop typing (a Saving… / Saved status appears next to it) — and that includes files you uploaded, not just files you created here. If the file is JSON, Markdown or code, a Preview button switches between editing it and reading it formatted. Text is capped at 200,000 characters; a bigger file opens read-only.

Uploaded files can be downloaded back to disk from the toolbar or the right-click menu.

Archives

Right-click any file or folder and choose Compress to ZIP. The archive is saved beside it as an ordinary file, so you can preview it, download it, or move it like anything else. A folder is compressed with everything inside it, keeping its structure.

Open a .zip and KimtFS shows you what is in it — every entry and its size — before you commit to unpacking it. Press Extract and the contents land in a new folder next to the archive.

It is all done in this tab, by the browser's own compressor, on bytes that are already on your device. Nothing is uploaded to be zipped, and nothing is downloaded to be unzipped. Every entry is checked against its checksum on the way out: a damaged archive fails and says so, rather than quietly writing corruption into your files.

Deleting, with a confirmation and an undo

Deleting asks first, and says exactly what will go — including how many items are inside a folder you are about to remove. After you confirm, an undo toast stays for about six seconds, so a mistaken "yes" is still recoverable. If you do not undo, the delete is committed and any uploaded bytes are freed.

The status bar

The bar along the bottom shows how many items you are looking at, and how much of the storage the browser has given this device is in use.

Architecture

KimtFS follows the suite convention: all data logic lives behind the local API layer, and the app itself is UI plus client-side file preview. The code lives in extension/src/apps/kimtfs/.

Modules

File	Role
meta.ts	The app manifest — id (kimtfs), display name (KimtFS), accent, order, plan, and App Store marketing copy.
index.ts	The app descriptor and UI — the path bar, the listing (columns or grid; sort, search, keyboard, multi-select), the text editor / file viewer, drag-and-drop, right-click context menus, Get Info, confirm-then-undo delete, and the agent tools array.
listing.ts	The rules behind the column list, kept free of the DOM so they can be tested: the Kind label, the sort comparator (folders first in both directions), the recursive search, and the Modified format.
viewer.ts	What you see when you open a file: the kind is detected from the name first (the mime type is the OS's guess, and it is often wrong), then rendered — image, audio, video, PDF (pdfjs-dist, imported lazily), JSON, code, or a capped hex dump.
zip.ts	The ZIP container, written by hand — local headers, the central directory, the end-of-central-directory record and a CRC-32. The compression itself is the browser's: CompressionStream('deflate-raw'). No dependency, and an entry is only inflated when it is actually extracted.
migrate.ts	The one-time copy of the old homefs-* partitions to kimtfs-*. Copies before it deletes, and is idempotent by construction.
kimtfs.local.ts	The data layer — folder/file/upload CRUD and blob storage over the shared IndexedDB, registered on the local API router. Every route awaits the migration first.
kimtfs.css	The app's styles for the path bar, the listing (columns and grid), the editor, and the viewers.

Data flow

The UI never touches storage directly: it calls getApi / jsonApi / callApi (the suite's local router), which dispatches to kimtfs.local.ts. Uploaded-file previews and downloads resolve a local object URL through fileUrl on the kimtfs/blob/:id route. The agent tools go through the same routes as the UI, so the assistant and the interface stay in sync.

Data model

Everything is a node in the kimtfs-nodes records collection, and the tree is formed entirely by the parentId link:

• Folder — { id, parentId, type: 'folder', name, createdAt, updatedAt }.
• Text file — { id, parentId, type: 'file', kind: 'text', name, text, size, createdAt, updatedAt }, where text is the inline content (capped at 200,000 characters) and size is its character length.
• Uploaded file — { id, parentId, type: 'file', kind: 'blob', name, size, mime, blobKey, createdAt, updatedAt }. The file's bytes live separately in the blobs store under the key kimtfs:<id>.

A parentId of '' (empty) places a node at the root. Listings return a "lean" view of each node (no inline text) for the tree; a file's full content is fetched only when it is opened.

Storage and operations

All persistent data goes through the shared dataStore (the single kimtos IndexedDB), partitioned by the app id:

• Records in the kimtfs-nodes collection hold every folder and file node.
• Blobs hold uploaded file bytes, keyed kimtfs:<id> for object-URL access.

Because both partitions are prefixed with the app id, AnubisDB attributes them to KimtFS automatically.

Key behaviors in the data layer:

• Recursive delete — deleting a folder walks its whole subtree and removes every descendant node, freeing each uploaded blob as it goes.
• Move guards — a folder can't be moved into itself or into one of its own subfolders; both cases are rejected.
• Text limit — creating or editing a text file over the 200,000-character limit is rejected. The UI checks the same limit before it opens an uploaded file for editing, so a file too big to save is never offered as editable.
• Autosave — text edits are debounced (~500 ms after the last keystroke) before being persisted via a PATCH.
• An edit goes where the bytes are — a PATCH carrying text updates the inline text field of a file created in the app, but rewrites the blob of an uploaded one. Writing the inline field on a blob node would leave the real bytes untouched and lose the edit.
• Delete-with-undo — the UI soft-hides a deleted item for ~6 seconds and only commits the recursive delete to storage if the undo window lapses.

Agent tools

KimtFS declares its capabilities as an MCP-shaped tools array on the app descriptor, for a future on-device assistant (they are dormant — no shipped model can run them). Each tool would run on-device through the same local routes as the UI:

Tool	Purpose
list_files	List every folder and file with id, name, type, kind, and parentId — used to find an item's id first.
create_folder	Create a folder under an optional parentId (root if omitted).
create_file	Create a text file with optional content under an optional parentId.
read_file	Read a text file's content by id; uploaded files return their metadata.
update_file	Replace a text file's content by id.
rename_item	Rename a folder or file by id.
delete_item	Delete a folder (and everything inside it) or a file by id.

Following suite conventions, these tools never throw — for a missing item or a validation failure they return an ok: false result an assistant could recover from — and their compact string results list ids so follow-up tool calls could reference them. (They are dormant: no shipped model can call them.)

Changelog

1.6.0 — 2026-07-25

• Preview video files with the app's themed player instead of the raw browser controls, and stop playback when you leave the file

1.5.0 — 2026-07-25

• Stop offering "Compress to ZIP" on a file that is already compressed — re-zipping it just wraps it in a bigger container

1.4.0 — 2026-07-25

• Preview audio files with the app's themed waveform player instead of the raw browser controls, and stop playback when you leave the file