Today, let’s talk about a situation that many of us have encountered: your trusty laptop suddenly stops working, and the project deadline is looming ever closer. Or maybe you’re on a business trip with only one available device — an outdated tablet, where even opening a browser takes multiple attempts. Sounds familiar?
In the age of remote work, such technical issues can seriously disrupt productivity. Sure, you could urgently purchase a new laptop or ask a colleague for a spare one, but what if there’s a more elegant solution?
Previously, we discussed Moonlight, an excellent tool for streaming resource-intensive applications that delivers impressive results with a high-quality wired connection. However, its requirements for the network infrastructure are quite high, and even the smallest internet issues can turn work into a real hassle.
Today, we’ll look at another approach: Kasm Workspaces, a solution initially designed not for gamers but for professional use. It is a platform for virtual workspaces that can transform almost any browser-enabled device into a fully functional workstation, providing access to necessary applications and operating systems via a web interface. Open your browser on a tablet - you get access to Ubuntu with VS Code, a complete working environment with the Chromium browser, and graphic tools (such as Gimp, Blender). Kasm ensures full isolation of user sessions, allows flexible configuration of computational resources for each workspace, integrates easily with existing corporate authentication systems, and maintains detailed logs of all actions for auditing purposes.
The primary use cases for Kasm are quite diverse. Programmers get ready-to-use development environments without spending time setting up their machines. Designers can run heavy graphic programs even on weak laptops. Testing teams create isolated environments to test software. Engineers and researchers gain remote access to mathematical packages or data analysis tools. However, there aren't any out-of-the-box commercial CAD programs or specific solutions available. You'll either need to package them into your own containers or connect existing infrastructure while considering all licensing requirements. On the other hand, the standard set of applications is impressive - ranging from ordinary browsers and office software to Blender, Unity Hub, and business messengers like Slack, Teams, and Zoom. The full list can be viewed in the repository kasmtech/workspaces-images.
This approach is very convenient for freelancers who need specific programs, small companies with remote employees, and organizations that do not want to invest in purchasing and maintaining multiple workstations. Kasm provides fully functional workspaces regardless of the user's location.
Comparing Kasm Workspaces Versions
Choosing the right version of Kasm Workspaces isn’t the easiest task. The developers have offered four main options, each tailored to specific needs and organizational sizes:
|
Feature |
Community Edition (CE) |
Starter Edition |
Enterprise (Server/Professional) |
Enterprise Cloud (WaaS) |
|---|---|---|---|---|
|
License/Price |
Free (for testing, non-profit, personal use) |
Paid, with limited features |
Paid, licensed per concurrent user |
Paid managed service (subscription-based) |
|
Target Audience |
Individual users, testing, evaluations |
Small teams/organizations up to ~25 users |
Medium and large organizations |
Organizations requiring a SaaS solution |
|
Deployment Model |
Self-hosted on one server/Docker |
Self-hosted, with limited functionality |
Self-hosted, with HA and customization options |
Managed cloud service |
|
Concurrent Session Limit |
Limited to ~5 concurrent sessions |
Up to ~25 users/sessions |
Licensed per concurrent user (flexible) |
Scalable, flexible based on contract |
|
Support/SLA |
Community support/issue tracker |
Self-support; paid support available |
Paid support/SLA |
Managed support 24/7 |
|
GPU/Performance Boost |
Limited; GPU availability depends on infrastructure |
GPU support available with the right setup |
GPU passthrough supported (for ML/video, depending on infrastructure) |
GPU instances available by contract |
|
SSO/LDAP/AD Integration |
Basic authentication/LDAP integration available |
Supported (LDAP/SSO) |
Full SSO/LDAP/AD integration |
Full integration with SSO/LDAP/AD |
|
Session Recording/Audit |
Limited; available for testing |
Basic options |
Session recording and audit capabilities |
Includes session recording and auditing as a service |
|
APIs/Integration Options |
Developer API and image availability |
APIs and images provided |
Complete set of APIs, with CI/CD support for images |
Managed images, integration with CI systems |
|
Setup and Maintenance Complexity |
Low complexity; quick proof-of-concept |
Medium complexity; requires administration |
High complexity; requires planning |
Low complexity for the customer |
|
Recommended Use Cases |
Testing, personal use |
Small groups |
Corporate DaaS/VDI, ML/EDA applications, security requirements |
Large teams, SLA needs, rapid deployment |
The Community Edition is perfect for getting started with the platform – you can set it up in just a few hours and evaluate its features without any financial investment. The Starter Edition represents a logical upgrade for small teams that need more users but don’t yet require enterprise-level functionality.
Enterprise versions, on the other hand, differ significantly in terms of their integration with corporate infrastructure. The Server/Professional edition offers complete control over the deployment process, which is crucial for organizations with strict security requirements. Lastly, the Cloud version eliminates the operational burden on the IT department by providing all the necessary features as a ready-to-use service.
Resource Recommendations
Now let’s discuss the technical requirements. One of Kasm’s main strengths is its scalability – it can be tailored to meet your needs, from home use to large-scale corporate deployments with thousands of users.
It’s important to understand that, unlike traditional “heavy client” architectures where computations take place on the user’s device, Kasm operates using a centralized resource model. This means all the processing is handled by the server, while client devices merely serve as display terminals.
Below is a table with recommended configurations for various use cases:
|
Processor |
Memory (GB) |
Storage (GB) |
Network |
GPU |
|
|---|---|---|---|---|---|
|
*1–5 concurrent sessions (personal use) |
2–4 vCPUs |
8 GB |
50–100 GB SSD (NVMe recommended)* |
50–100 Mbps |
Not required |
|
*10–25 concurrent sessions (small department, laboratory) |
8–12 vCPUs |
32 GB |
200–400 GB SSD/NVMe |
100–300 Mbps |
Optional (for graphics or video)* |
|
*50–100 concurrent sessions (medium-sized company) |
24–32 vCPUs (multi-core Xeon/EPYC)* |
128 GB |
1–2 TB SSD/NVMe |
1 Gbps (with backup)* |
1–2 server GPUs (NVIDIA A10/A40 or similar) for graphics and ML tasks |
|
*200+ concurrent sessions (large enterprise, university) |
64–128 vCPUs (cluster of multiple nodes)* |
256–512 GB |
5+ TB NVMe |
10 Gbps |
Multiple NVIDIA A100/L40 GPUs for heavy-duty tasks |
As can be seen from the table, the requirements are increasing in a fairly predictable manner. For initial experiments, a standard VPS with basic configuration is more than sufficient, which makes the entry barrier quite low. However, when scaling up, it’s important to consider not only the number of concurrent sessions but also the nature of the tasks being performed—working with heavy IDEs, rendering, and machine learning all require appropriate resources.
Special attention should be paid to network requirements: unlike Moonlight, Kasm is more tolerant of connection quality, but bandwidth remains a critical factor, especially when working with graphical applications.
Testing
The testing was conducted on a real VPS server under load. The system operated without any restarts for two days, after which a comprehensive analysis of all infrastructure components was performed.
To fully evaluate the performance and stability of Kasm Workspaces, a specialized bash script was developed to automatically test all key system components.
Testing Architecture
The testing script performs a sequential check of critical areas:
- System Resources – Gathering basic information about the server (CPU, RAM, disk usage, load).
- Docker Containers – Analyzing the status of all Kasm services and their resource consumption.
- Network Configuration – Checking active ports and network connections.
- APIs and Web Interfaces – Testing the response times of main endpoints.
- SSL Certificates – Validating the security of connections.
- Log Analysis – Searching for errors in the logs of all containers.
- Performance Testing – Measuring response times under load.
- Available Images – Inventorying installed workspaces.
- Storage Analysis – Evaluating disk space usage.
- Overall Evaluation – Aggregating results and assigning an overall health score to the system.
Measurement Tools
API Response Time: The curl command was used to measure execution times in nanoseconds.
bash
start_time=$(date +%s%N)
code=$(curl -sk -o /dev/null -w "%{http_code}" --connect-timeout 10 "$url" 2>/dev/null)
end_time=$(date +%s%N)
response_time=$(( ($end_time - $start_time) / 1000000 ))
Performance Stress Test: A 30-second test using stress-ng that simulates a load on 2 CPU cores and 256MB of RAM, with system metrics being monitored every 5 seconds.
Resource Monitoring: Utilizing native Docker commands (docker stats) to obtain real-time data on resource usage by containers.
Testing Environment: The testing was conducted on a VPS with the following specifications:
- CPU: 4 cores
- RAM: 4GB
- Disk: 59GB SSD
- Operating System: Ubuntu Server
- System uptime: More than 10 hours of continuous operation
All measurements were performed locally on the server to eliminate the impact of network latency on the results of API and web interface testing.
System Performance
|
Component |
Value |
Comment |
|---|---|---|
|
Load Average: 0.15–0.17 |
The system is not overloaded. |
The system is not overloaded |
|
CPU Usage: 65–77% under load |
There is some performance headroom available. |
There is reserve capacity |
|
Memory Usage: 29–36% |
Only 4GB of RAM is being used (which might be limited). |
Only 4 GB of RAM is a bit low |
|
Disk Usage: 42% (out of 59GB) |
Sufficient disk space is available. |
Enough space available |
|
API Response Time: 23–26 ms |
Immediate response times are achieved. |
Instant response |
The results for the web interface performance test were particularly impressive; all ten test requests to the API were successfully processed with an average response time of 24 milliseconds, which is faster than many local applications on less powerful computers.
Docker Container Status
Kasm Workspaces consists of a complex ecosystem comprising ten interconnected containers. The analysis revealed that all components are operating stably:
|
Container |
RAM Usage (MB) |
CPU Usage (%) |
Status |
Runtime (hours) |
|---|---|---|---|---|
|
kasm_db |
264 MB |
0.23% |
Healthy |
More than 10 hours |
|
kasm_api |
188 MB |
0.16% |
Healthy |
More than 10 hours |
|
kasm_guac |
168 MB |
0.00% |
Healthy |
More than 10 hours |
|
kasm_manager |
149 MB |
0.00% |
Healthy |
More than 10 hours |
|
kasm_proxy |
25 MB |
0.00% |
Running |
More than 10 hours |
The most resource-intensive components were the PostgreSQL database and the API server, which is expected for a system of this scale. It’s important to note that even with limited resources, all services on the VPS operated stably without any need for restarts.
Workspace Configuration
|
Application |
CPU Cores |
Memory (Actual Value, GB) |
Image Size (GB) |
|---|---|---|---|
|
Blender |
2 |
2.6 |
3.73 |
|
GIMP |
2 |
2.6 |
2.66 |
|
Visual Studio Code |
2 |
2.6 |
3.63 |
The configuration demonstrates a consistent allocation of resources. Each workspace is allocated 2.6 GB of RAM, which is an optimal value for running graphic applications. All workspaces use the same processor configuration (2 cores), ensuring stable performance.
The size of the image files varies depending on the application’s requirements: Blender requires the most disk space (3.73 GB), reflecting its role as a powerful 3D editor; in contrast, GIMP has the smallest image file size (2.66 GB).
Resources and Performance Under Load
One of the key questions when using cloud solutions is whether the system can handle real-world workloads. We conducted a stress test to simulate high levels of activity:
|
Test Time |
Load Average |
CPU Usage |
Memory Usage |
|---|---|---|---|
|
Idle State |
0.15 |
~5% |
29% |
|
5 Seconds of Load |
0.37 |
65.7% |
35.8% |
|
15 Seconds of Load |
0.85 |
74.6% |
35.8% |
|
30 Seconds of Load |
1.32 |
67.2% |
36.0% |
The results are impressive: even under artificial load on two CPU cores and an additional 256 MB of memory, the system remained responsive. The Load Average increased to 1.32, which is normal for a four-core system. Memory usage was hardly affected, indicating an efficient container architecture.
Disk Space Analysis
For remote work, it’s crucial to understand how much space various applications are taking up and how much free space is left:
|
Category |
Size |
Percentage |
Potential Optimization |
|---|---|---|---|
|
Docker Images |
7.4 GB |
12% of disk space |
5.08 GB can be removed |
|
Containers |
1.7 KB |
~0% |
Minimal overhead |
|
Volumes |
324 MB |
0.5% |
Contains user data |
|
Free Space |
33 GB |
56% |
Reserved for future use |
The most “resource-intensive” applications were the full-featured ones: Visual Studio Code occupies 3.63 GB, and Blender takes up 3.73 GB. This is comparable to installing these programs on a local computer. However, in the cloud, you get a ready-to-use environment without the need for any configuration or dependency installation.
Conclusion
The test results demonstrate that even a budget-friendly VPS can serve as a viable alternative to a dedicated desktop computer. With an interface response time of 24 milliseconds, tasks can be completed comfortably even over a slow connection. The system’s stability under load indicates its capability to handle resource-intensive tasks.
Of course, there are limitations: 4 GB of RAM may be sufficient for most office tasks, but it might not be enough for complex graphic work or large-scale data analysis. The 60 GB of disk space is adequate for projects of moderate complexity; however, additional storage will be needed for archiving and storing media files.
Overall, Kasm Workspaces represents a mature and practical solution for organizing remote work. It effectively fulfills its primary purpose by providing access to fully functional work environments regardless of the user’s location or the technical specifications of their device.