Cloud services have quietly become part of everyday life. Files are stored in online drives, meetings are scheduled through web calendars, and contact lists live somewhere on remote servers. While these services are convenient, they also mean that personal information is continuously stored and processed on infrastructure that users do not control. For many developers and privacy-conscious users, this trade-off raises an important question. Is it possible to keep the same convenience while maintaining control over the data?
Self-hosting has long been the answer, but traditional platforms often come with complexity and heavy resource requirements. This is where OxiCloud enters the picture. It is an open source, self hosted cloud platform designed to deliver file storage, calendar synchronization, and contact management in a lightweight and efficient way.
What is OxiCloud
OxiCloud is a Rust based application that combines three essential services into a single platform. It provides file storage through a web interface and WebDAV, calendar synchronization using CalDAV, and contact management using CardDAV.
Rust plays an important role in the design of the system. Applications written in Rust compile into native binaries that are efficient and memory safe. As a result, OxiCloud starts quickly and consumes significantly fewer resources compared with many traditional self hosted cloud platforms.
The project was originally created as a response to performance concerns with heavier solutions such as Nextcloud on home servers. Instead of requiring a complex stack with multiple services and high memory usage, OxiCloud focuses on simplicity and speed.
Some highlights of the platform include:
- Idle memory usage around 30 to 50 MB
- Docker image size close to 40 MB
- Cold start time under one second
- Support for WebDAV, CalDAV, CardDAV, and a REST API
- Authentication using JWT tokens with Argon2id password hashing
- Support for OpenID Connect and single sign on
- Content deduplication and resumable uploads
- Full text search across stored files
These characteristics make it suitable for small servers, Raspberry Pi deployments, or low-cost virtual machines.
Why Self-Hosting Matters
The popularity of commercial cloud platforms comes from their simplicity. Upload a file, and it appears across all devices. Add a calendar event, and it syncs instantly. Save a contact, and it becomes accessible everywhere.
However, the convenience hides a dependency. Data is stored on servers controlled by large companies, and the rules governing that data can change at any time. Terms of service updates, pricing changes, or company acquisitions can influence how data is handled.
Running your own cloud service changes this dynamic. Data remains on the infrastructure you manage. You decide where backups are stored, who can access the system, and when updates are applied.
The challenge has traditionally been the setup process. Many self-hosted platforms require web servers, scripting languages, databases, and careful configuration. OxiCloud aims to reduce this barrier by offering a compact application that can be deployed quickly with minimal overhead.
Core Features
File Storage and Management
OxiCloud provides a browser-based interface for managing files along with WebDAV support for external clients. Users can upload files through drag and drop in the browser or synchronize them with desktop applications.
Large file uploads are handled through a chunked upload mechanism that allows interrupted transfers to resume rather than restart from the beginning. This is particularly useful when transferring large media files.
Storage efficiency is improved through content addressing using SHA-256 hashes. If the same file is uploaded multiple times, it is stored once and referenced internally. This prevents duplicate storage consumption.
Search capabilities allow users to locate files by name, type, size, or modification date. A soft delete system places removed files into a trash folder where they can be recovered before automatic cleanup.
For image collections, the system generates optimized thumbnails using formats such as WebP and AVIF.
Calendar Synchronization with CalDAV
Calendars in OxiCloud rely on the CalDAV protocol, which is widely supported by many desktop and mobile applications. Once connected, events created on any device synchronize with the OxiCloud server.
Users can manage multiple calendars, create recurring events, and maintain synchronization across different devices without sending data to third-party cloud providers.
Compatible clients include Apple Calendar, Thunderbird, Evolution, and Android devices through DAVx⁵.
Contact Management with CardDAV
OxiCloud also manages address books using the CardDAV protocol. Contact information, including phone numbers, email addresses, notes, and birthdays, remains stored on the server.
Most operating systems already support CardDAV or can connect through standard applications. Migrating contacts typically involves exporting a VCF file from an existing service and importing it into the new system.
This makes it possible to move contact data away from commercial platforms while maintaining compatibility with existing devices.
Security and Authentication
Security is a core part of the platform’s design. Passwords are hashed using Argon2id, which is widely considered one of the strongest modern hashing algorithms.
Authentication sessions use JSON Web Tokens, and refresh tokens are rotated to reduce the risk of session abuse. For organizations or advanced deployments, OxiCloud also supports OpenID Connect and single sign-on integration.
Access control features allow administrators to define folder permissions, assign user storage quotas, and create password-protected sharing links.
Protocol and API Support
In addition to the web interface, OxiCloud exposes several protocols for integration with other tools. WebDAV enables file synchronization through desktop clients. The REST API allows programmatic access to stored data and metadata.
The system also includes support for WOPI integration, which enables browser-based editing of documents when connected to compatible document servers.
Performance Perspective
One of the most notable aspects of OxiCloud is its efficiency. Traditional platforms designed around scripting languages and large dependency stacks often require significant memory and storage resources.
In contrast, OxiCloud focuses on minimal resource consumption. A typical deployment may show:
- Idle memory usage between 30 and 50 MB
- Cold start times under one second
- Docker image sizes around 40 MB
This difference becomes especially noticeable on low-power hardware. Home servers and small virtual machines can run OxiCloud alongside other services without noticeable slowdowns.
Prerequisites for Deployment
Before running OxiCloud, a few basic tools are required.
- Docker and Docker Compose installed on the host machine
- At least 512 MB of available memory
- A system running Linux, macOS, or Windows with WSL2
On Ubuntu or Debian systems, Docker can be installed with:
sudo apt update
sudo apt install docker.io docker-compose-plugin
sudo systemctl enable docker --now
sudo usermod -aG docker $USER
After adding the user to the Docker group, logging out and back in will apply the changes.
Step 1: Clone the Repository
Start by downloading the project from GitHub and preparing the configuration file.
git clone https://github.com/DioCrafts/oxicloud.git
cd oxicloud
cp example.env .env
The .env file contains environment variables used by the application. Review the database credentials and application URL before starting the service.
Example configuration:
POSTGRES_DB=oxicloud
POSTGRES_USER=oxicloud
POSTGRES_PASSWORD=changeme
APP_URL=http://localhost:8086
For production use, replace the default password with a strong one.
Step 2: Start the Services
Once the configuration is ready, launch the containers using Docker Compose.
docker compose up -d
Docker will download the necessary images and start both the OxiCloud application container and the PostgreSQL database container.
To confirm everything is running:
docker compose ps
If troubleshooting is required, logs can be inspected with:
docker compose logs oxicloud
Step 3: Initial Setup
Open a browser and navigate to:
http://localhost:8086
The interface will prompt you to create the first administrator account. This account manages users, storage quotas, and system settings.
Once logged in, the dashboard provides access to file storage, shared items, and system configuration. The settings panel also lists the endpoints for WebDAV, CalDAV, and CardDAV connections.
Step 4: Remote Access with Pinggy
Running the service locally works well for testing, but a personal cloud becomes more useful when accessible from anywhere.
Pinggy provides a quick way to expose a local service through a secure public URL using a single SSH command.
ssh -p 443 -R0:localhost:8086 -t free.pinggy.io
After connecting, Pinggy generates a public HTTPS address. Visiting that URL in a browser opens the OxiCloud interface from outside the local network.
For additional access protection, HTTP basic authentication can be added:
ssh -p 443 -R0:localhost:8086 -t free.pinggy.io "b:username:password"
This approach makes remote access possible without configuring routers or managing DNS records.
Running OxiCloud Without Docker
Developers who prefer running applications directly can build OxiCloud from source using Rust.
First install Rust through rustup, then build the project:
git clone https://github.com/DioCrafts/oxicloud.git
cd oxicloud
cargo build --release
Once compiled, the application can be launched with:
cargo run --release
Ensure that PostgreSQL is running and the environment variables in the .env file are configured correctly.
Security Considerations
Self-hosting offers control, but it also introduces responsibility. A few practical steps help maintain a secure deployment.
Running the service behind a reverse proxy such as Nginx or Caddy allows the use of TLS certificates from Let’s Encrypt. Database access should remain restricted to the local host. Firewall rules should limit access to the application port.
Regular backups are also essential. The PostgreSQL database can be backed up using pg_dump, while uploaded files should be copied from the Docker volume.
Migrating Data from Existing Services
Moving from other platforms is generally straightforward because standard formats are widely supported.
From Nextcloud:
- Export files or synchronize them locally through WebDAV
- Export calendar data as ICS files
- Export contacts as VCF files
From Google services:
- Use Google Takeout to download calendar and contact archives
- Import the ICS and VCF files into OxiCloud
Large file collections can be uploaded through the browser interface or synchronized through WebDAV clients.
Conclusion
OxiCloud illustrates how modern software design can simplify self-hosting. By combining Rust’s performance advantages with standard synchronization protocols, it delivers a personal cloud platform that is efficient and easy to deploy.
Instead of depending on multiple commercial services for file storage, calendars, and contacts, a single lightweight application can handle all three. With minimal hardware requirements and quick startup times, it fits naturally into home servers and small development environments.
When paired with simple tunneling tools such as Pinggy, even remote access becomes straightforward. For developers interested in maintaining control over their data while keeping the familiar convenience of cloud tools, OxiCloud provides a practical and efficient path forward.
Reference
Self-Hosted Cloud Storage, Calendar and Contacts with OxiCloud
Top comments (0)