Meet Velocity, the next-generation cloud workspace that gives you instant, secure, and collaborative VS Code and Jupyter Lab environments powered by Daytona sandboxes.

Introducing Velocity: Instant Cloud Dev Environments Powered by Daytona Sandboxes

"The laptop was meant to be a portable client, not a portable server farm. Velocity finally realizes the vision of thin-client development with thick-cloud power." — Sarah Jenkins, CTO at Acme Corp

The way we build software has fundamentally changed. In 2026, the era of spending hours configuring local environments, fighting the infamous "it works on my machine" syndrome, and melting your laptop's battery to run heavy AI models locally is officially over.

Today, we are thrilled to announce Velocity, our next-generation Cloud Workspace platform. Velocity provides instant, secure, and infinitely scalable development environments right in your browser. Whether you need a fully-featured VS Code instance for your massive monorepo or a GPU-accelerated Jupyter Lab for your data science team, Velocity has you covered.

And the best part? It's all powered by the incredible orchestration engine of Daytona Sandboxes.

The End of Local Development Pain

Let’s face it, modern development is demanding. A typical full-stack application today might involve:

• A heavy frontend framework (Next.js, Nuxt, SvelteKit, etc.)
• Multiple backend microservices written in Go, Rust, or Python
• Local instances of Postgres, Redis, and Kafka
• Background AI agent processes requiring significant RAM and compute
• Complex Docker and Kubernetes local setups

Your local machine, no matter how specced out, is a single point of failure. It lacks the network bandwidth of a data center, it drains battery, and it creates massive onboarding friction for new team members. Have you ever spent your first three days at a new job just trying to get the development environment to compile? We have too, and it's unacceptable.

The Shift to the Cloud

Over the past few years, the industry has slowly shifted towards remote development. However, early solutions were often clunky, slow, or lacked the native feel of a local IDE. Network latency made typing feel sluggish, and missing extensions drove developers crazy.

Enter Velocity Cloud Workspace

Velocity takes your entire development environment—your source code, runtimes, extensions, databases, and dependencies—and moves them into a high-performance cloud container located geographically close to you.

We built Velocity with three core principles:

1. Zero Friction: Go from a GitHub URL to a running IDE in less than 2 seconds.
2. Infinite Power: Scale your workspace CPU and RAM dynamically without restarting.
3. Absolute Security: Isolated, ephemeral environments that never leak data.

Under the Hood: Powered by Daytona Sandboxes

To achieve blazing fast startup times and rock-solid reliability, we partnered with Daytona. Velocity environments are built on top of Daytona Sandboxes, an enterprise-grade container orchestration system designed specifically for development workloads.

Why Daytona?

Unlike standard Docker containers, Daytona Sandboxes provide a unique blend of virtual machine-level isolation with container-level speed. They are built for multi-tenancy, meaning your code is completely secure from other users on the platform.

Daytona provides root-level isolation, fast snapshotting, and advanced networking out of the box. When you launch a Velocity workspace, the Daytona engine pre-fetches your repository, mounts a high-speed NVMe block volume, and injects your preferred IDE server.

Here is a look at the Velocity architecture:

graph TD
    %% Velocity Architecture Diagram
    User[Developer / Browser] -->|HTTPS/WSS| LB[Velocity Edge Load Balancer]
    
    subgraph Velocity Cloud Infrastructure
        LB --> Gateway[API Gateway & Auth]
        Gateway --> ControlPlane[Velocity Control Plane]
        
        ControlPlane -->|Provisioning| DaytonaEngine{Daytona Sandbox Engine}
        
        subgraph Daytona Sandboxes
            WorkspaceA[Workspace A: VS Code + Node.js]
            WorkspaceB[Workspace B: Jupyter Lab + Python + GPU]
            WorkspaceC[Workspace C: VS Code + Go + Redis]
        end
        
        DaytonaEngine --> WorkspaceA
        DaytonaEngine --> WorkspaceB
        DaytonaEngine --> WorkspaceC
        
        WorkspaceA -.->|Attached| NVMe1[(NVMe Storage Volume)]
        WorkspaceB -.->|Attached| NVMe2[(NVMe Storage Volume)]
        WorkspaceC -.->|Attached| NVMe3[(NVMe Storage Volume)]
    end

    GitHub[GitHub / GitLab / Bitbucket] -->|Webhooks & Source| ControlPlane

Prebuilds: The Secret to Instant Environments

With Daytona's prebuild technology, Velocity listens to webhooks from your git provider. Every time a PR is opened or a commit is pushed, Velocity builds the environment in the background. It downloads the base image, clones the code, runs npm install or pip install, and snapshots the memory state.

When you click "Open in Velocity", you aren't waiting for dependencies to download. You are instantly attached to a warmed-up, ready-to-code snapshot. This turns a 5-minute coffee break into a 2-second blink.

VS Code & Jupyter Lab in the Browser

Developers have strong preferences for their tools. We didn't want to reinvent the wheel by building a proprietary editor. Instead, we bring your favorite tools directly into the browser with zero compromises.

VS Code in Browser

Velocity streams a fully-featured, extension-compatible version of VS Code directly to your browser. It looks, feels, and performs exactly like your local desktop app.

• Full Extension Support: Install any extension from the Open VSX registry or Microsoft marketplace.
• Dotfiles Sync: Velocity automatically pulls your dotfiles repository, setting up your custom aliases, ZSH themes, and vim bindings the moment the workspace boots.
• Port Forwarding: Seamlessly forward localhost ports to secure public or private URLs.
• Integrated Terminal: Full root terminal access to your Daytona sandbox. Type htop and watch the cloud cores hum.

Jupyter Lab for Data Science

For our AI, ML, and Data Science users, you can select Jupyter Lab as your IDE.

• Instant GPU Access: Attach NVIDIA A100 or H100 GPUs to your workspace with a single click. Train models in minutes instead of days.
• Persistent Data: Your datasets, model weights, and notebooks remain securely stored on your isolated NVMe volume, even if the workspace is paused.
• Conda Environments: First-class support for Conda, letting you manage complex ML dependencies without polluting the global environment.

Configuration as Code: velocity.yml

Configuring your workspace is as simple as adding a velocity.yml file to the root of your repository. Velocity automatically detects this file and provisions the exact environment your project needs.

Here is an example of configuring a standard Full Stack application:

# velocity.yml
version: "1.0"

# Choose your base image
image: velocity/ubuntu-base:latest

# Define the IDE
ide: 
  default: vscode
  extensions:
    - dbaeumer.vscode-eslint
    - eamodio.gitlens
    - github.copilot

# Daytona Sandbox compute resources
compute:
  cpu: 8
  memory: 16GB

# Lifecycle hooks
tasks:
  - name: Install Dependencies
    init: npm install
  - name: Run Database Migrations
    init: npm run db:migrate
  - name: Start Dev Server
    command: npm run dev

# Port configuration
ports:
  - port: 3000
    visibility: public
    onOpen: open-browser
  - port: 5432
    visibility: private

And for a Data Science project utilizing Jupyter Lab and GPUs:

# velocity.yml
version: "1.0"
image: velocity/ml-base:cuda-12

ide:
  default: jupyterlab

compute:
  cpu: 16
  memory: 64GB
  gpu: 
    type: A100
    count: 1

tasks:
  - name: Setup Conda
    init: conda env create -f environment.yml

Unlocking Desktop Integrations with the Velocity CLI

While the browser experience is flawless, some developers absolutely refuse to leave their native desktop environment. We hear you. That’s why we built the Velocity CLI.

By running a simple command, you can mount your remote cloud workspace directly into your local IDE.

# Install the Velocity CLI
curl -sL https://velocity.dev/install.sh | bash

# Authenticate with your account
velocity login

# Start a workspace and connect your local VS Code or SSH
velocity up --repo your-org/your-repo --ide local-vscode

The CLI utilizes Daytona's advanced SSH tunneling capabilities to ensure that your keystrokes are transmitted securely and with minimal latency.

The Velocity REST API

For platform engineers who want to automate workspace creation, we offer a comprehensive REST API.

Need to spin up a workspace as part of your CI/CD pipeline to run end-to-end tests against a live environment? Just hit our /v1/workspaces endpoint.

curl -X POST https://api.velocity.dev/v1/workspaces \
  -H "Authorization: Bearer $VELOCITY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "repository": "acmecorp/backend",
    "branch": "feature/new-api",
    "machine_type": "standard-8"
  }'

Extending Velocity with Custom Plugins

One of the most requested features during our beta was the ability to extend the workspace lifecycle. With the launch of Velocity 1.0, we are introducing Velocity Plugins.

Using standard WebAssembly (Wasm), you can write custom lifecycle hooks that execute during workspace initialization, pause, or teardown. Whether you need to fetch short-lived AWS credentials from HashiCorp Vault or trigger a Slack notification when a heavy ML training job completes, Velocity Plugins give you complete programmatic control over your cloud environments.

Secure Repository Sharing & Collaboration

Collaboration is where Velocity truly shines. Have you ever tried to help a colleague debug a complex issue, only to spend 30 minutes getting their environment running on your machine?

With Velocity, you can share a live link to your running workspace.

Zero-Trust Sharing Model

• Live Pair Programming: Multiple cursors and shared terminals in real-time. You can literally watch your co-worker type and execute commands.
• Access Control: Grant "View Only", "Terminal Access", or "Full Edit" permissions to specific team members.
• Ephemeral Link Expiry: Shared links can be configured to expire after a set time or when the workspace pauses.
• Audit Logs: Enterprise admins can view detailed logs of who accessed which workspace, satisfying SOC2 and ISO27001 compliance requirements.

Here is how collaboration flows securely through our Daytona-backed network:

sequenceDiagram
    participant DevA as Developer A (Host)
    participant Velocity as Velocity Proxy
    participant Sandbox as Daytona Sandbox
    participant DevB as Developer B (Guest)

    DevA->>Velocity: Request Share Link (Read/Write)
    Velocity-->>DevA: Returns Secure URL
    DevA->>DevB: Sends Link via Slack/Teams
    DevB->>Velocity: Authenticates & Connects to URL
    Velocity->>Sandbox: Verifies IAM & Establishes WSS tunnel
    Sandbox-->>DevB: Syncs Workspace State
    DevB->>Sandbox: Types Code / Runs Terminal
    Sandbox-->>DevA: Real-time UI Update

Security & Enterprise Compliance

We understand that source code is a company's most valuable intellectual property. By moving source code off local laptops and into Velocity's secure sandboxes, you instantly mitigate the risk of lost laptops or stolen IP.

• Data at Rest: All NVMe volumes are encrypted with AES-256.
• VNet Injection: For Enterprise customers, Velocity workspaces can be deployed directly into your own AWS VPC or Azure VNet, keeping traffic entirely internal.
• SSO & SAML: Deep integration with Okta, Google Workspace, and Azure AD to enforce corporate access policies.

Case Study: How Acme Corp Scaled with Velocity

Acme Corp, a massive fintech organization with over 500 engineers, transitioned from local environments to Velocity last quarter. Their engineering metrics improved drastically:

• Onboarding Time: Reduced from 4 days to 45 minutes.
• Build Times: A massive Go microservices compile that took 12 minutes locally now takes 2 minutes on Velocity's 32-core cloud instances.
• Infrastructure Costs: By pausing idle workspaces, Acme Corp reduced their cloud development spend by 30% compared to legacy persistent EC2 instances.

"Velocity completely transformed how our engineering organization operates. It eliminated the 'works on my machine' problem entirely and boosted developer happiness," said Jane Doe, VP of Engineering at Acme Corp.

Performance Benchmarks

We claim Velocity is fast, but let's look at the numbers. We benchmarked a standard Next.js monolithic repository across various environments, testing for I/O operations, network speed, and startup latency.

Velocity’s use of localized Daytona sandboxes and native NVMe block storage gives it a massive edge in raw I/O performance over legacy cloud IDEs.

Pricing Comparison: Velocity vs The Competition

We believe cloud workspaces should be accessible to solo developers and powerful enough for enterprise teams. Here is how we stack up against the market in 2026.

1. Velocity (Our Platform)

• Free Tier: 50 hours/month of standard compute (4 core, 8GB RAM). Perfect for weekend projects and open-source contributions.
• Pro Tier ($15/mo): Unlimited standard compute. Pay-as-you-go for GPU/High-CPU instances.
• Enterprise: Custom SLA, VPC peering, and SAML SSO.
• Value: The absolute best bang for your buck, combining consumer-friendly pricing with Daytona's enterprise performance.

2. GitHub Codespaces

• Pricing: No unlimited tier. Pay per hour for compute and pay per GB for storage, even when inactive.
• Drawbacks: Can get incredibly expensive for large teams quickly. Storage fees add up. Startup times can lag on cold boots.

3. Replit

• Pricing: Replit Core is $25/mo.
• Drawbacks: Great for prototyping, but Replit's custom IDE often lacks the enterprise features, robust extension ecosystem, and deep monorepo support that professional developers require.

4. Daytona (Self-Hosted)

• Pricing: Enterprise contracts.
• Drawbacks: Daytona is an incredible engine (which is why we use it!), but self-hosting and managing the infrastructure requires a dedicated DevOps team. Velocity gives you the power of Daytona as a fully managed SaaS.

Frequently Asked Questions (FAQ)

Q: Can I use Velocity offline? A: Because Velocity workspaces run entirely in the cloud, an internet connection is required. However, our optimized WebSocket protocol ensures a smooth typing experience even on high-latency connections.

Q: Are my secrets secure? A: Absolutely. Secrets are encrypted at rest using AES-256 and injected into your workspace purely as environment variables. They are never written to the disk.

Q: Can I connect my desktop VS Code to Velocity? A: Yes! If you prefer your desktop app, you can use the Velocity CLI to create an SSH tunnel and connect your local desktop IDE directly to the remote workspace.

Q: What if I forget to turn off my workspace? A: Velocity automatically pauses idle workspaces after 30 minutes of inactivity to save resources, keeping your costs down automatically.

Q: Do you support custom Dockerfiles? A: Yes. If our base images don't meet your needs, you can simply point velocity.yml to a custom Dockerfile or docker-compose.yml file, and we will build it on the fly.

Q: Can I run Android/iOS emulators? A: We are actively working on supporting nested virtualization for mobile emulators. It is currently in private beta and will be rolled out to Pro users next month.

Getting Started

The future of development is in the cloud. It's time to reclaim your local RAM, stop waiting for dependencies to download, and start shipping code faster. By abstracting away the hardware, Velocity lets you focus on what you do best: writing great software.

Are you ready to experience the ultimate cloud IDE?

1. Sign up for a free Velocity account at https://velocity.dev.
2. Connect your GitHub, GitLab, or Bitbucket account.
3. Select a repository and click "Open in Velocity".

Within 2 seconds, you'll be greeted by a fully functional, lightning-fast VS Code or Jupyter environment.

Join the revolution of instant dev environments today.

Velocity Engineering Team — August 27, 2026