Your files never leave your device. All processing happens locally in your browser.
How do I create a .tar.gz (tarball) file online without uploading my files?
Open TAR.GZ Creator, then drop files or an entire folder onto the page — or click to pick them. Choose TAR.GZ (gzip-compressed) or plain TAR, set a Fast, Balanced or Maximum gzip level, name the archive, and optionally rename entries or edit their folder paths; the folder tree you dropped is preserved. Click Create and the tool bundles everything into a single POSIX ustar tarball and, for .tar.gz, deflates it with gzip — all in your browser — then hands you a download. It handles up to 1,000 files and 2 GB per file. Nothing is uploaded: the archive is built entirely on your device, so your files never leave the tab.
Builds real .tar and .tar.gz archives in the browser — no upload, no tar command, no install
Drop whole folders and the directory structure is preserved inside the archive
Pick TAR.GZ or TAR and a Fast / Balanced / Maximum gzip level; live estimated output size
POSIX ustar format that untars cleanly on Linux, macOS and WSL
Rename files, edit folder paths and reorder entries before creating; up to 1,000 files, 2 GB each
What is
TAR.GZ Creator
A TAR.GZ creator is a tool that packs many files and folders into a single archive and compresses it. It performs two distinct steps: tar (tape archive) concatenates the files into one uncompressed container that records each entry’s path, size, timestamp and type, and gzip then DEFLATE-compresses that whole stream into a .tar.gz (also written .tgz) — a “gzipped tarball”. Because tar bundles first and gzip compresses the combined block, the compressor can find patterns across files, so a .tar.gz is typically smaller than compressing each file separately. Tarballs are the default way software, source code and backups are distributed on Unix-like systems. This tool writes the POSIX ustar variant of tar and applies gzip entirely in the browser, so it needs no tar or gzip command line and never uploads your data.
No. The tarball is assembled and gzip-compressed entirely in your browser, so the files never leave your device — there is no upload, server or account.
Nothing is uploaded. When you drop or pick files, the tool reads them locally with the browser’s File API, writes the POSIX ustar tar structure in memory and, for .tar.gz, runs the gzip DEFLATE compression on your device with the pako library. There is no server, API, database or tracking in the processing path, so source code, documents and backups stay on your machine; the tool works offline once cached, and closing the tab discards everything. The only optional network use anywhere on the site is consent-gated advertising, which never sees your files.
A .tar just bundles files without shrinking them; a .tar.gz bundles and then gzip-compresses, so it is smaller. Pick TAR.GZ unless you need an uncompressed archive.
TAR only archives: it stitches your files into one container but does not compress, so a .tar is roughly the sum of its contents. GZIP only compresses a single stream, so the two are combined — tar first, gzip second — to make a .tar.gz that is both bundled and shrunk. Choose TAR.GZ for the smallest file and for anything you will download or share; it compresses text, code and logs a lot and already-compressed data such as JPEG, MP4 or ZIP barely at all. Choose plain TAR when the contents are already compressed, when you want the fastest creation, or when another step will compress the archive later. This tool offers both and, for TAR.GZ, a Fast, Balanced or Maximum gzip level to trade speed against size.
Yes. Drop a folder or use “Pick an entire folder” and the nested directory tree is preserved inside the archive; you can also edit any entry’s folder path.
You can drag a folder straight onto the page or use the folder picker, and the tool walks the directory tree so every file keeps its relative path inside the tarball — extracting the archive later recreates the same folders. Each staged entry shows its folder prefix and filename as editable fields, so you can rename files, retarget them into a different sub-folder, reorder them or remove them before creating. This makes it easy to reshape a loose set of files into a tidy, well-structured .tar.gz.
Yes. It writes the standard POSIX ustar tar format, so tar -xzf, GNU tar, bsdtar and desktop archivers all extract it normally.
The archive is written in the POSIX ustar format that GNU tar and bsdtar produce, with correct 512-byte headers, checksums and path handling, so it extracts cleanly with tar -xzf archive.tar.gz on Linux, macOS and the Windows Subsystem for Linux, and opens in graphical tools such as The Unarchiver, Ark or 7-Zip. Because .tar.gz is the native distribution format on Unix-like systems, the files you create here are interchangeable with those produced by the command line; there are practical limits though — everything runs in browser memory, so the tool caps at 1,000 files and 2 GB per file.
Detailed Explanation
📖How It Works
Building TAR and TAR.GZ Archives in Your Browser
TAR.GZ Creator bundles files and folders into a single .tar or gzip-compressed .tar.gz archive without uploading anything. Drop files or an entire folder onto the page — or use the file and folder pickers — and every item is staged with its folder path and filename shown as editable fields, so you can rename, re-path, reorder or remove entries before building. Pick TAR.GZ (a “gzipped tarball”) or plain TAR, choose a Fast, Balanced or Maximum gzip level, and name the archive; a live summary shows the file count, total size and an estimated output size. Click Create and the tool concatenates the files into a POSIX ustar tarball and, for .tar.gz, gzip-compresses that stream on your device, then offers a single download and reports how much smaller the result is. It handles up to 1,000 files and 2 GB per file.
Creates real .tar and .tar.gz archives entirely in the browser — no upload, no tar command
Drop whole folders and the nested directory tree is preserved inside the archive
TAR.GZ or TAR, with Fast / Balanced / Maximum gzip levels and a live estimated output size
Rename, re-path, reorder and remove entries; up to 1,000 files and 2 GB per file
📋Use Cases
Packaging Source Code, Backups and Uploads
The commonest job is producing a .tar.gz the way Unix and Linux workflows expect one: bundling a source tree, a set of config files, logs or a backup into a single compressed tarball to email, attach to a release, upload to a server or hand to a build pipeline. Because whole folders can be dropped and the directory structure is kept, you can package a project directory in one step and it will untar into the same layout on the other end. The editable entries make it easy to tidy things first — rename a file, move a stray file into a sub-folder, drop something you do not want to ship — without touching the originals on disk. For distribution, .tar.gz at a higher gzip level keeps the download small; for a fast local bundle of already-compressed media, plain TAR avoids wasting time compressing data that will not shrink.
Bundle a source tree, configs, logs or a backup into one .tar.gz for release or upload
Dropped folders preserve their structure, so archives untar into the same layout
Tidy entries (rename, re-path, remove) without altering the files on disk
Higher gzip for small downloads; plain TAR for a fast bundle of already-compressed media
🔧Technical Details
How the Tar Writer and Gzip Step Work
Each file is read with the browser File API and written into a minimal, hand-rolled POSIX ustar tar stream. Every entry gets a 512-byte header carrying the path (split across the ustar name and prefix fields for long paths), the size and modified time as octal, a type flag, the “ustar” magic at offset 257, and a header checksum; the file data follows and is NUL-padded up to the next 512-byte boundary, with the archive terminated by the required trailing zero blocks. For a plain .tar that byte stream is the finished archive. For .tar.gz the whole tar buffer is then piped through gzip using the pako library at the level you chose — 3 (Fast), 6 (Balanced) or 9 (Maximum) — producing a standard DEFLATE-compressed .gz wrapper. Dropped folders are enumerated with the browser’s webkitGetAsEntry directory walker (and the webkitdirectory picker), so relative paths are captured accurately. All of this runs synchronously in the page with a progress callback; nothing is streamed to a server.
Long paths split across the ustar name and prefix fields; data NUL-padded to 512-byte blocks
TAR.GZ pipes the tar buffer through pako.gzip at level 3, 6 or 9 (Fast / Balanced / Maximum)
Folders enumerated via webkitGetAsEntry and the webkitdirectory picker to keep relative paths
⚠️Limitations
Honest Limitations
Everything runs in browser memory, so the archive and its gzip buffer must fit in RAM: the tool caps at 1,000 files and 2 GB per file, and very large totals can be slow or memory-bound, especially at the Maximum gzip level. The estimated output size shown before you build is a heuristic — it assumes roughly 55% of the original for .tar.gz and the full size for .tar — because the real ratio depends entirely on your content; text and code shrink a lot while already-compressed formats such as JPEG, MP4 and ZIP barely shrink at all, so the finished size can differ from the estimate. The tool writes the widely-supported ustar format rather than the GNU or PAX extensions, so extremely long paths beyond the ustar name/prefix limit or exotic metadata are out of scope, and it stores file contents and timestamps but not Unix ownership or permission bits, symlinks or extended attributes. It creates archives only — extracting a tarball is a separate tool.
In-memory build: up to 1,000 files and 2 GB per file; large totals are RAM- and time-bound
The pre-build size is an estimate; the real ratio depends on how compressible your files are
Writes portable ustar, not GNU/PAX extensions; stores contents and mtime, not owners/permissions or symlinks
Creates archives only; it does not extract or open existing tarballs
🔒Privacy & Security
Privacy: Your Files Stay on Your Device
The files you archive are often the sensitive kind — private source code, database dumps, document sets, personal backups — and this tool is built so none of them leave your machine. Each file is read with the File API and packed into the tarball entirely in browser memory, and the gzip compression runs locally in the same page with the pako library; there is no server, upload, database, logging, API or CDN anywhere in the processing path, and even the final .tar.gz download is generated on your device. The tool works offline once the page has been cached, and closing the tab discards every byte. There is no login and no telemetry, and the only optional network use anywhere on the site is consent-gated advertising, which never sees your files.
Files read, archived and gzip-compressed entirely in the browser
No server, upload, database, API or CDN in the processing path
Even the final .tar.gz is generated locally; works offline once cached
No login or telemetry; closing the tab discards everything
TAR.GZ Creator — formats, options and limits
Capability
Support
Notes
Output formats
TAR and TAR.GZ (.tgz)
Plain uncompressed tarball or gzip-compressed tarball, both POSIX ustar
Compression
Gzip levels 3 / 6 / 9
Fast, Balanced or Maximum via pako; TAR is stored uncompressed
Folders
Full directory tree preserved
Drag a folder or use the folder picker; relative paths captured with webkitGetAsEntry
Editing
Rename, re-path, reorder, remove
Each entry’s folder path and filename are editable before building
Compatibility
ustar — extracts everywhere
Untars with tar -xzf, GNU tar, bsdtar, The Unarchiver, Ark and 7-Zip on Linux, macOS and WSL
Limits & scale
Up to 1,000 files, 2 GB each
In-memory build bounded by device RAM; creates archives only; 100% client-side, no upload
TAR.GZ Creator builds .tar and gzip-compressed .tar.gz archives in the browser: files or whole folders are staged with editable paths and names, packed into a POSIX ustar tarball, and — for .tar.gz — gzip-compressed with pako at a Fast, Balanced or Maximum level, then downloaded with a live estimated size. It handles up to 1,000 files and 2 GB per file, preserves dropped directory structure, and produces archives that untar cleanly on Linux, macOS and WSL. Everything runs in memory; nothing is uploaded.
