Rust · 1.86

Rust hosting, 24/7

Ship an axum API, a serenity bot or a queue worker and leave it running. cargo build --release happens while the image is built, the target/release binary starts in an isolated container, and the platform restarts the process on its own, on every plan, when it crashes.

Create account See plans

Origin

Who designed Rust

Graydon Hoare started Rust in 2006 as a personal project; Mozilla adopted it in 2009 for the Firefox engine. The bet was C-like control without dangling pointers and without a garbage collector: the compiler refuses the dangerous alias. After years of breaking change, 1.0 shipped in 2015 with a stability promise. Ownership and borrowing are the mechanism, not a library.

Systems without a garbage collector

Rust wants C and C++ control without dangling pointers and without pausing the program to collect memory. That is the bet — not “yet another new language”.

The compiler is the referee

Ownership and borrowing refuse the dangerous alias at compile time. What other languages leave to runtime, rustc decides before it emits the binary.

Native, no VM

There is no virtual machine in the middle. The purpose is the same as a classic systems language: what comes out is code for the processor, with a guarantee C does not give.

What the platform does for a Rust project

The essentials come configured on every Rust application here; the features that depend on your plan are flagged in the card.

Release build in the image

Crates from Cargo.toml are fetched and compiled while the image is built, not on every boot. The container starts with the target/release binary ready, and a compile error shows up in the build log instead of becoming a crash in production.

Three versions, one config line

1.86 (recommended), 1.87 and 1.85 are available. Switching means changing VERSION in vertracloud.config and deploying again — there is no image to pick and no Dockerfile to maintain.

RAM ceiling in the config file

MEMORY sets how much memory the container may take, and the dashboard shows real usage next to that ceiling. If the process goes past the limit it is killed by OOM, and the event is recorded in the log.

Auto-restart with a brake

An unwrap that blows up in production does not leave the service down: the process is restarted on its own, on every plan. If it breaks 5 times in 10 minutes, the platform flags a crash loop and turns auto-restart off for 24 hours. Exiting with code 0 does not trigger a restart.

What people run in Rust here

Long, predictable workloads: that is where a low memory cost per request shows up on the monthly bill.

APIs in axum, actix-web and warp

Publish the application to get a vertraweb.app subdomain with TLS. The release binary already carries the server: it only has to listen on 0.0.0.0:80, because anything bound to localhost never sees a request from outside.

Bots and background services

serenity, twilight and API clients run as a process with no HTTP port. The token goes in the environment variables tab, never in a .env inside the zip — the platform does not read .env files.

Workers and data pipelines

Queue consumer, indexer, processing routine: long workloads where memory cost per request matters. The dashboard shows real RAM next to the MEMORY ceiling, and a process that goes past the limit is killed by OOM.

A native connector on a managed database

A PostgreSQL 17 created in the same dashboard talks to sqlx or tokio-postgres over the internal host. TLS is mandatory, and the client certificate and password come straight out of the dashboard into your connector.

Available Rust versions

1.86 is the recommended one, 1.87 is the latest and 1.85 is still available. With no VERSION in vertracloud.config, the application starts on the recommended one.

Version	vertracloud.config	Status
1.87	VERSION=1.87	Latest
1.86	VERSION=1.86	Recommended
1.85	VERSION=1.85

The entire configuration

vertracloud.config is an optional INI file at the root of the project. MAIN points to the binary in target/release; VERSION picks the Rust release; MEMORY sets the container's RAM ceiling.

vertracloud.config

NAME=meu-worker
MAIN=target/release/app
VERSION=1.86
MEMORY=512

A plan for every stage of the project

Memory and storage change with the plan; the language does not. Compare what each plan unlocks and pick the one that fits the project today.

Compare plans

Also runs here

Same platform, same deploy, a different stack.

Java

Python

Frequently asked questions about Rust hosting

Compilation, MAIN and memory: the most frequent questions from people shipping Rust.

Which Rust versions can I use?

1.86 is the recommended one, 1.87 is the latest and 1.85 is still available. The choice is made with the VERSION key in vertracloud.config; without it, the application starts on the recommended one.

Where should MAIN point?

To the executable produced by the release profile, usually target/release/ plus the name declared in Cargo.toml. Pointing at the debug binary works, but it is larger and slower in production.

Can I upload an already compiled binary instead of the source?

The binary targets a different operating system or architecture. Build for Linux x86_64, or — the simpler path — upload the source with Cargo.toml and Cargo.lock and let the compilation happen in the platform build.

How much memory does my service need?

It depends on the workload, and the dashboard shows the container's real usage. If the process is killed by OOM, raise MEMORY. Publishing to the web requires 512 MB of RAM and the Pro plan.

Should I upload the target folder in the zip?

No — and please do not. Leave target out of the package: it is usually the largest folder in the project, the zip limit is 100 MB, and the build is redone on the server, for Linux.

Deploy your Rust service today

Create an account, upload the source with Cargo.toml and Cargo.lock or connect your GitHub repository, and follow cargo build --release in the dashboard terminal.

Create account