# EnvSift: open source .env tools that run in your browser

URL: https://pixelactstudio.com/work/envsift

> EnvSift is an open source app by Damn Labs at Pixelact Studio that compares, validates, and converts .env files in your browser. See how it was built.

Label: Open Source. Status: Live.

- **Type:** Open source web app with six tools for working with .env files
- **Built by:** Pixelact Studio, under its Damn Labs branch
- **License:** Apache License 2.0
- **Status:** Live at envsift.damnlabs.com. Latest release 0.2.0, July 2026
- **Platform:** Any modern browser, served as prerendered static files from Cloudflare Pages. Runs locally with Node.js and pnpm
- **Stack summary:** TypeScript, React 19, TanStack Start, Tailwind CSS, shadcn/ui on Base UI, Vitest, and cookieless PostHog analytics
- **Privacy model:** Pasted text and local files are processed in the browser tab. Analytics events never include keys, values, or filenames

- [Open EnvSift](https://envsift.damnlabs.com)
- [Source on GitHub](https://github.com/pixelactstudio/envsift)

EnvSift is an open source web app, built by Pixelact Studio under its Damn Labs branch, that compares, validates, merges, formats, redacts, and converts `.env` files. Pasted text and local files are processed in the browser tab, so no application server receives them. It is free at envsift.damnlabs.com and licensed under the Apache License 2.0.

## What does the EnvSift open source toolkit do?

EnvSift gives developers six tools for the jobs that come up as soon as an app runs in more than one environment. Problems are reported by line number, and the formatter, merger, and converter refuse input with syntax errors rather than guess.

**The six EnvSift tools**

| Tool | What it does | Detail that matters |
| --- | --- | --- |
| ENV Compare | Finds missing and changed variables across two or more files | Values stay hidden until you reveal them, and it can copy the entries each file is missing |
| `.env.example` Generator | Removes values to make a template teammates can copy | Comments stay as written, so read them before committing. Invalid or duplicate lines become comments saying they were left out |
| ENV Validator | Checks syntax and common mistakes | Flags invalid lines, duplicate keys, empty values, `${NAME}` references to missing variables, and stray whitespace |
| Merge & Clean | Merges two files into one sorted file | One file wins every conflict, or you choose per key, and no output appears until all are resolved |
| ENV Formatter | Normalizes quotes and ordering and drops duplicate assignments | It refuses to strip quotes from a value that contains spaces or special characters |
| Format Converter | Converts ENV or flat JSON to ENV, JSON, shell exports, or Docker Compose | Compose output can carry the values or `${NAME}` references |

It is for the developer joining a project who needs a working `.env`, the engineer chasing a setting that differs between staging and production, and the team moving configuration into Docker Compose. There is no account and nothing to install.

## What problem does EnvSift solve?

EnvSift catches configuration drift, the gaps between `.env` files that surface as runtime errors after a deploy. A variable added on one laptop never reaches `.env.example`, or staging carries a key that production lacks.

Comparing files by eye misses things, and pasting them into an online diff tool can send live credentials to a server nobody on the team controls. EnvSift keeps the work in the tab, and anyone can check that: the parser, the analytics filter, and the tests are public, and the browser's network panel shows every request the page makes.

## How does EnvSift work?

EnvSift is a static site. TanStack Start prerenders its pages at build time, and all processing happens in client-side TypeScript in the open tab.

1. **Read.** You paste text, pick a file, or drop one. The browser's File API reads the file inside the tab, and the filename stays out of analytics.
2. **Parse.** One function, `parseEnv`, turns the text into entries with line numbers and a list of issues marked as errors or warnings.
3. **Transform.** Compare, validate, merge, format, and convert all work from that parsed result, so each of them reads a file the same way.
4. **Output.** Copy uses the Clipboard API, and downloads are built as local blobs. Editor contents are never saved, so closing the tab clears them.

The same functions are open to AI agents. In browsers that support [WebMCP](https://github.com/webmachinelearning/webmcp), a draft web API that lets a page offer tools to AI agents in the browser, EnvSift registers six tools that mirror the visible ones. Each is marked read-only and rejects any input string over 100,000 characters. The validator tool returns line numbers, key names, and counts, never values.

The tools still run in the tab, but anything a person hands to a browser agent also falls under that agent provider's privacy terms. The EnvSift privacy page says so plainly.

## What was hard to build?

Three parts of EnvSift took the most care: parsing the files developers actually write, converting values without changing them, and measuring use without collecting content.

### Parsing the files people actually write

There is no single `.env` standard. Real files hold PEM private keys across several lines, `export` prefixes, inline comments, and quotes escaped with backslashes. The parser keeps reading a quoted value until it finds a closing quote preceded by an even number of backslashes, so an escaped quote at the end of a line does not cut the value short.

A line that is not a portable `KEY=value` assignment, with a key of letters, digits, and underscores that does not start with a digit, becomes an error with a line number, never a silent guess.

### Conversions that keep values exact

Converting is where values quietly change. A JavaScript number cannot represent every integer above 9,007,199,254,740,991, the value of `Number.MAX_SAFE_INTEGER`, so a long numeric ID in JSON input can be rounded on the way through. `JSON.parse` has already rounded it by the time it returns, so the converter scans the raw JSON text and rejects those numbers with a request to quote them.

Docker Compose reads a dollar sign as the start of a variable, and [Docker's interpolation reference](https://docs.docker.com/reference/compose-file/interpolation/) says a literal one must be written as `$$`. The converter turns `${HOST_SECRET}` inside a value into `$${HOST_SECRET}`, using a replacer function because `replaceAll` reads `$$` in a replacement string as a single dollar sign. Shell exports wrap each value in single quotes, so `$HOME` inside a value stays literal, and they split the quoting around any single quote in the value.

### Measuring use without collecting content

Version 0.1.0 configured PostHog to keep its identifier in local storage. Work on 0.2.0 tried a consent banner first, then replaced it before release with PostHog's cookieless mode, which keeps no analytics identifier in cookies or browser storage.

A filter drops any event that is not on an allowlist and any custom event property that is not listed for that event. It also strips query strings and fragments from URLs and turns exact counts into buckets such as 11 to 50 variables. The README states the cost: weekly and monthly unique-user counts are not reliable.

## What does EnvSift show about how Pixelact builds software?

EnvSift shows the practices we use for [product development](https://pixelactstudio.com/services/product-development): automated checks on every change, tests for the privacy promises, scope decided in writing, and AI-drafted work merged only after review.

- **Every change passes the same gate.** CI runs Vitest, the TypeScript compiler, ESLint, a Prettier check, and a full production build on every push and pull request, the checks our [engineering standards](https://pixelactstudio.com/about/engineering-standards) require on every project. Cloudflare Pages deploys a preview of each pull request, and commit hooks lint staged files and enforce Conventional Commits.
- **Tests guard the promises, not only the features.** They check that a generated `.env.example` drops the values it was given, that the WebMCP validator returns no values, that analytics never receive editor state, and that page metadata carries no invented review data such as star ratings.
- **Scope is decided in writing.** The product brief defers a hosted secret vault, secret rotation, and automatic production sync. In the planned repository scanner, AI may only suggest changes for a person to accept, and repository changes arrive as visible pull requests.
- **AI speeds up the work, and review stays.** Later features, such as the SEO guides and the WebMCP tools, were drafted by an AI coding agent on short-lived branches. Each pull request passed CI and an automated correctness check before a person merged it, as in our [AI code review workflow](https://pixelactstudio.com/blog/ai-code-review-workflow).

EnvSift is one of the free tools from [Damn Labs, Pixelact Studio's lab](https://pixelactstudio.com/labs). In a live product, a [software audit](https://pixelactstudio.com/services/software-audits) covers the same ground and more: configuration drift between environments, where secrets are stored, and [API keys exposed in frontend code](https://pixelactstudio.com/blog/exposed-api-keys).

## The decisions behind EnvSift

### No application server

**What we chose:** EnvSift ships as prerendered static files, and every tool runs in client-side TypeScript inside the open tab.

**Why:** People paste live credentials into tools like this. With no server that receives content, there is no server copy of a credential to protect or delete, and anyone can confirm what leaves the page in the browser's network panel.

### One parser behind the tools

**What we chose:** Compare, validate, format, merge, and convert all read input through one `parseEnv` function, and the six WebMCP tools offered to browser agents call those same functions.

**Why:** Two parsers would disagree on multi-line values or escaped quotes, and a fix in one would miss the other. With one parser, each edge case is fixed and tested once, and a single test runs a multi-line private key through the formatter, the converter, and the merger.

### Analytics that fail closed

**What we chose:** Each custom analytics event has a typed list of allowed properties, a filter drops any event or property that is not listed, counts are bucketed, and PostHog runs in cookieless mode.

**Why:** A denylist leaks the first property nobody thought to block. An allowlist keeps a new field out of analytics until someone adds it on purpose, and tests check that no editor content reaches a captured event.

### A configuration tool, not a secret vault

**What we chose:** The product brief plans to grow EnvSift toward an environment contract: variable names, where each one is expected, and findings, with values left on the developer's machine or with the deployment provider.

**Why:** A hosted vault, secret rotation, and automatic production sync would turn EnvSift into security-critical infrastructure. The brief defers them, and the planned server would store names, metadata, and scan history, never values.