Render Runtime Options

Complete guide to available runtimes on Render, including versions, configuration, and best practices for each language.

Native Language Runtimes

Node.js (runtime: node)

Supported Versions: 14, 16, 18, 20, 21 Default Version: 20

Version Specification:

Specify Node version in package.json:

{
  "engines": {
    "node": "20.x"
  }
}

Package Managers:

• npm: Default, uses package-lock.json
• Yarn: Auto-detected if yarn.lock exists
• pnpm: Auto-detected if pnpm-lock.yaml exists

Common Build Commands:

npm ci                          # Recommended (faster, reproducible)
npm ci && npm run build         # Build step included
yarn install --frozen-lockfile  # Yarn equivalent
pnpm install --frozen-lockfile  # pnpm equivalent

Common Start Commands:

npm start                       # Uses "start" script in package.json
node server.js                  # Direct file execution
node dist/main.js               # Built output

Popular Frameworks:

• Express.js, Fastify, Koa (APIs)
• Next.js (full-stack React)
• Nest.js (enterprise TypeScript)
• Remix (full-stack React)
• Nuxt.js (full-stack Vue)

Example Configuration:

type: web
name: node-app
runtime: node
buildCommand: npm ci && npm run build
startCommand: npm start

Python (runtime: python)

Supported Versions: 3.8, 3.9, 3.10, 3.11, 3.12 Default Version: 3.11

Version Specification:

Option 1 - runtime.txt:

python-3.11.5

Option 2 - Pipfile:

[requires]
python_version = "3.11"

Package Managers:

• pip: Default, uses requirements.txt
• Poetry: Auto-detected if pyproject.toml exists
• Pipenv: Auto-detected if Pipfile exists

Common Build Commands:

pip install -r requirements.txt
pip install -r requirements.txt && python manage.py collectstatic --no-input
poetry install --no-dev
pipenv install --deploy

Common Start Commands:

gunicorn app:app                                    # Flask
gunicorn config.wsgi:application                    # Django
uvicorn main:app --host 0.0.0.0 --port $PORT       # FastAPI
celery -A tasks worker                              # Celery worker

Popular Frameworks:

• Django (full-stack web framework)
• Flask (microframework)
• FastAPI (modern async API framework)
• Celery (task queue)

Example Configuration:

type: web
name: python-app
runtime: python
buildCommand: pip install -r requirements.txt
startCommand: gunicorn app:app --bind 0.0.0.0:$PORT

Go (runtime: go)

Supported Versions: 1.20, 1.21, 1.22, 1.23 Default Version: Latest stable

Version Specification:

Specify in go.mod:

module myapp

go 1.22

Build System: Uses Go modules

Common Build Commands:

go build -o bin/app .
go build -o bin/app cmd/server/main.go
go build -tags netgo -ldflags '-s -w' -o bin/app

Common Start Commands:

./bin/app
./bin/server

Popular Frameworks:

• net/http (standard library)
• Gin (fast web framework)
• Echo (high performance framework)
• Chi (lightweight router)
• Fiber (Express-inspired framework)
• Gorilla Mux (powerful router)

Example Configuration:

type: web
name: go-app
runtime: go
buildCommand: go build -o bin/app .
startCommand: ./bin/app

Ruby (runtime: ruby)

Supported Versions: 3.0, 3.1, 3.2, 3.3 Default Version: 3.3

Version Specification:

Option 1 - .ruby-version:

3.3.0

Option 2 - Gemfile:

ruby '3.3.0'

Package Manager: Bundler (uses Gemfile and Gemfile.lock)

Common Build Commands:

bundle install --jobs=4 --retry=3
bundle install && bundle exec rails assets:precompile

Common Start Commands:

bundle exec rails server -b 0.0.0.0 -p $PORT
bundle exec puma -C config/puma.rb
bundle exec rackup -o 0.0.0.0 -p $PORT
bundle exec sidekiq                                  # Worker

Popular Frameworks:

• Ruby on Rails (full-stack framework)
• Sinatra (microframework)
• Sidekiq (background jobs)

Example Configuration:

type: web
name: rails-app
runtime: ruby
buildCommand: bundle install && bundle exec rails assets:precompile
startCommand: bundle exec puma -C config/puma.rb

Rust (runtime: rust)

Supported Versions: Latest stable Default Version: Latest stable

Build System: Cargo

Common Build Commands:

cargo build --release
cargo build --release --locked

Common Start Commands:

./target/release/myapp

Popular Frameworks:

• Actix Web (powerful, performant)
• Rocket (web framework with focus on usability)
• Axum (modern, ergonomic framework)
• Warp (composable web framework)

Example Configuration:

type: web
name: rust-app
runtime: rust
buildCommand: cargo build --release
startCommand: ./target/release/myapp

Elixir (runtime: elixir)

Supported Versions: Latest stable Default Version: Latest stable

Build System: Mix

Common Build Commands:

mix deps.get --only prod
mix deps.get && mix compile
mix do deps.get, compile, assets.deploy

Common Start Commands:

mix phx.server
elixir --name myapp -S mix phx.server

Popular Frameworks:

• Phoenix (full-stack web framework)
• Phoenix LiveView (real-time applications)

Example Configuration:

type: web
name: elixir-app
runtime: elixir
buildCommand: mix deps.get --only prod && mix compile
startCommand: mix phx.server

Container Runtimes

Docker (runtime: docker)

Build your application from a Dockerfile in your repository.

Additional Configuration:

• dockerfilePath: Path to Dockerfile (default: ./Dockerfile)
• dockerContext: Build context directory (default: .)

Example Configuration:

type: web
name: docker-app
runtime: docker
dockerfilePath: ./Dockerfile
dockerContext: .

Multi-stage Dockerfile Example:

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm ci --only=production
EXPOSE 10000
CMD ["node", "dist/main.js"]

Best Practices:

• Use multi-stage builds to reduce image size
• Copy package.json before source code (better caching)
• Use .dockerignore to exclude unnecessary files
• Expose port dynamically via $PORT environment variable
• Run as non-root user for security

Pre-built Image (runtime: image)

Deploy pre-built Docker images from a container registry.

Additional Configuration:

• image: Full image URL with tag or digest
• registryCredential: Credentials for private registries

Example with Public Image:

type: web
name: prebuilt-app
runtime: image
image: ghcr.io/myorg/myapp:v1.2.3

Example with Private Registry:

type: web
name: private-app
runtime: image
image: myregistry.com/myapp:latest
registryCredential:
  username: my-username
  password:
    sync: false  # User provides in Dashboard

Use Cases:

• Deploy images built in CI/CD pipeline
• Use images from container registries
• Deploy Docker Hub images
• Use private registry images

Static Runtime (runtime: static)

Serve pre-built static files without a backend runtime. Files are served via CDN.

Additional Configuration:

• staticPublishPath: Directory containing built files (e.g., ./dist, ./build)

Common Build Commands by Framework:

React (Create React App):

npm ci && npm run build
# Outputs to: ./build

Vue:

npm ci && npm run build
# Outputs to: ./dist

Next.js (Static Export):

npm ci && npm run build && npm run export
# Outputs to: ./out

Gatsby:

npm ci && npm run build
# Outputs to: ./public

Vite:

npm ci && npm run build
# Outputs to: ./dist

Example Configuration:

type: web
name: react-app
runtime: static
buildCommand: npm ci && npm run build
staticPublishPath: ./build

Runtime Comparison

Choosing the Right Runtime

Choose Node.js when:

• Building JavaScript-based applications
• Need rich npm ecosystem
• Want fast iteration and deployment
• Building full-stack applications (Next.js, Remix)

Choose Python when:

• Building data-heavy applications
• Need machine learning libraries
• Django or Flask expertise
• Data processing pipelines

Choose Go when:

• Need high performance and low resource usage
• Building microservices
• Want simple deployment (single binary)
• Handling high concurrency

Choose Ruby when:

• Building traditional web applications
• Ruby on Rails expertise
• Rapid development priority

Choose Rust when:

• Maximum performance required
• Systems programming
• Resource-constrained environments

Choose Docker when:

• Need custom system dependencies
• Multi-language application
• Existing Dockerfile
• Need full control over environment

Choose Static when:

• Building SPAs or static sites
• No backend processing needed
• Want CDN caching and fast delivery
• Documentation or marketing sites