Technical Documentation: VERT-sh/VERT

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`) Copy Section

[VERT.sh](https://vert.sh)

VERT is a file conversion utility that uses WebAssembly to convert files on your device instead of a cloud. Check out the live instance at vert.sh.

VERT is built in Svelte and TypeScript.

Screenshots Copy Chapter

Features Copy Chapter

• Convert files directly on your device using WebAssembly*
• No file or file size limits
• Convert images, audio, documents, and video*
• Supports over 250+ file formats
• Conversion settings
• User-friendly interface built with Svelte

^{* Local video conversion in-browser is supported, but some conversion may require server-side processing. Server video conversion is available with our official instance, but the daemon is easily self-hostable to maintain privacy and fully local functionality.}

Documentation Copy Chapter

• FAQ
• Getting Started
• Using Docker
• Video Conversion

Contributing Copy Chapter

Refer to our contributing guidelines before opening an issue or pull request here: CONTRIBUTING.md

License Copy Chapter

This project is licensed under the AGPL-3.0 License, please see the LICENSE file for details.

Star History Copy Chapter

DOCKER (`docs/DOCKER.md`) Copy Section

Using Docker Copy Chapter

This file covers how to run VERT under a Docker container.

• Manually building the image
• Using an image from the GitHub Container Registry

Manually building the image Copy Section

First, clone the repository:

git clone https://github.com/VERT-sh/VERT
cd VERT/

Then build a Docker image with:

docker build -t vert-sh/vert \
    --build-arg PUB_ENV=production \
    --build-arg PUB_HOSTNAME=vert.sh \
    --build-arg PUB_PLAUSIBLE_URL=https://plausible.example.com \
    --build-arg PUB_VERTD_URL=https://vertd.vert.sh \
    --build-arg PUB_DONATION_URL=https://donations.vert.sh \
	--build-arg PUB_DISABLE_ALL_EXTERNAL_REQUESTS=false \
    --build-arg PUB_STRIPE_KEY="" .

You can then run it by using:

docker run -d \
    --restart unless-stopped \
    -p 3000:80 \
    --name "vert" \
    vert-sh/vert

This will do the following:

• Use the previously built image as the container vert, in detached mode
• Continuously restart the container until manually stopped
• Map 3000/tcp (host) to 80/tcp (container)

We also have a docker-compose.yml file available. Use docker compose up if you want to start the stack, or docker compose down to bring it down. You can pass --build to docker compose up to rebuild the Docker image (useful if you've changed any of the environment variables) as well as -d to start it in detached mode. You can read more about Docker Compose in general here.

Using an image from the GitHub Container Registry Copy Section

While there's an image you can pull instead of cloning the repo and building the image yourself, you will not be able to update any of the environment variables (e.g. PUB_PLAUSIBLE_URL) as they're baked directly into the image and not obtained during runtime. If you're okay with this, you can simply run this command instead:

docker run -d \
    --restart unless-stopped \
    -p 3000:80 \
    --name "vert" \
    ghcr.io/vert-sh/vert:latest

FAQ (`docs/FAQ.md`) Copy Section

FAQ Copy Chapter

This file covers frequently asked questions.

• Why VERT?
• What happens with video files?
• Can I host my own video file converter?
• What about analytics?
• What libraries does VERT use?
• Is it possible to fully prevent VERT from making requests to external services?

Why VERT? Copy Section

File converters have always disappointed us. They're ugly, riddled with ads, and most importantly; slow. We decided to solve this problem once and for all by making an alternative that solves all those problems, and more.

All non-video files are converted completely on-device; this means that there's no delay between sending and receiving the files from a server, and we never get to snoop on the files you convert.

What happens with video files? Copy Section

Video files get uploaded to our lightning-fast RTX 4000 Ada server. Your videos stay on there for an hour if you do not convert them. If you do convert the file, the video will stay on the server for an hour, or until it is downloaded. The file will then be deleted from our server.

Can I host my own video file converter? Copy Section

Yes. Check out the Video Conversion page.

What about analytics? Copy Section

We use Plausible, a privacy-focused analytics tool, to gather completely anonymous statistics. All data is anonymized and aggregated, and no identifiable information is ever sent or stored. You can view the analytics here and choose to opt out in the Settings page.

Is it possible to fully prevent VERT from making requests to external services? Copy Section

Yes! If you would prefer VERT to not make any requests to external services (video conversion, analytics, among others), you can set the PUB_DISABLE_ALL_EXTERNAL_REQUESTS environment variable to true during build time.

What libraries does VERT use? Copy Section

VERT uses FFmpeg for audio and video conversion, imagemagick for images and Pandoc for documents. A big thanks to them for maintaining such excellent libraries for so many years.

GETTING STARTED (`docs/GETTING_STARTED.md`) Copy Section

Getting Started Copy Chapter

This file covers how to get started with VERT.

• Prerequisites
• Installation
• Running Locally
• Building for Production
• Using Docker

Prerequisites Copy Section

Make sure you have the following installed:

• Bun

Installation Copy Section

First, clone the repository:

git clone https://github.com/VERT-sh/VERT
cd VERT/

Install dependencies:

bun i

And finally, make sure you create a .env file in the root of the project. We've included a .env.example file which you can use to get started.

Running Locally Copy Section

To run the project locally, run bun dev.

This will start a development server. Open your browser and navigate to http://localhost:5173 to see the application.

Building for Production Copy Section

To build the project for production, run bun run build.

This will build the site to the build folder. You should then use a web server like nginx to serve the files inside that folder.

Using Docker Copy Section

Check the dedicated Docker page.

VIDEO CONVERSION (`docs/VIDEO_CONVERSION.md`) Copy Section

Video conversion Copy Chapter

This file covers how video conversion works when using VERT.

On VERT, video processing is done locally in your browser whenever possible using Mediabunny. However, some conversions may require server-side processing if it's unsupported or too slow to do it in the browser for some reason.

Server-side processing is done through vertd, which is a simple FFmpeg wrapper built in Rust. If you don't understand all that technical jargon, it basically allows you to convert videos using the full capacity of your computer, which results in more conversions supported and being much faster. It runs on your computer (or a server somewhere, if you know what you're doing), and the VERT web interface reaches out to it in order to convert your videos, if it requests for it.

We host an official instance of vertd so you do not have to host it yourself for convenience, but considering you're here, you probably want to host it for yourself. Essentially:

• Download the latest release of vertd for your machine here
• Run the server
• Connect the VERT UI to your local vertd instance by entering its IP & port
  • By default, vertd runs a HTTP server on port 24153, so you would put http://localhost:24153 in the "Instance URL" setting found in VERT's settings (assuming you are running it on your own PC)

--- METRICS ---

• Files Extracted: 5
• Estimated Token Budget: ~2367 tokens
• Canonical Reference: https://codewiki.google/github.com/VERT-sh/VERT