https://github.com/omniflare/docker-vue
🚀 DockerVue - A Modern Docker Desktop Alternative A blazing-fast, lightweight Docker management UI built with Rust, Tauri, and React. Perfect for Linux users who want a native-like Docker experience without the heavy resource overhead. ✨ Key Features: - 🐳 Full Docker container management - 📦 Image handling with real-time progress - 🔌 Network
https://github.com/omniflare/docker-vue
docker docker-desktop rust-project tauri tauri-app tauri-apps
Last synced: about 2 months ago
JSON representation
🚀 DockerVue - A Modern Docker Desktop Alternative A blazing-fast, lightweight Docker management UI built with Rust, Tauri, and React. Perfect for Linux users who want a native-like Docker experience without the heavy resource overhead. ✨ Key Features: - 🐳 Full Docker container management - 📦 Image handling with real-time progress - 🔌 Network
- Host: GitHub
- URL: https://github.com/omniflare/docker-vue
- Owner: omniflare
- Created: 2025-01-08T12:54:25.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2025-01-08T16:37:26.000Z (over 1 year ago)
- Last Synced: 2025-07-09T08:07:40.633Z (11 months ago)
- Topics: docker, docker-desktop, rust-project, tauri, tauri-app, tauri-apps
- Language: TypeScript
- Homepage:
- Size: 277 KB
- Stars: 1
- Watchers: 3
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# DockerVue: A Modern Docker Desktop Alternative
[](https://www.rust-lang.org/)
[](https://tauri.app/)
[](https://reactjs.org/)
[](https://www.typescriptlang.org/)
A lightning-fast, resource-efficient alternative to Docker Desktop, built specifically with Linux users in mind. This project combines the power of Rust's performance with modern web technologies to create a seamless Docker management experience.
## 🌟 Why Another Docker Desktop?
While Docker Desktop is a fantastic tool, its implementation on Linux can be resource-intensive and sometimes sluggish. DockerVue was created to address these pain points by:
- Providing a native-like experience with minimal resource overhead
- Leveraging Rust's safety and performance capabilities
- Offering a modern, responsive UI that feels natural on Linux systems
- Ensuring smooth container management with real-time updates
## 🚀 Features
- **Container Management**
- Create, start, stop, and delete containers
- Real-time container logs
- Port mapping configuration
- Resource usage monitoring
- **Image Management**
- Pull, remove, and manage Docker images
- Image size tracking
- Repository tag management
- **Network Operations**
- Create and manage Docker networks
- Connect/disconnect containers to networks
- Network driver configuration
- **Volume Management**
- Create and manage Docker volumes
- Mount point visualization
- Volume driver support
## 🛠️ Technology Stack
### Backend (Tauri + Rust)
- **Tauri**: Provides the application framework and native capabilities
- **Bollard**: Rust Docker API client for container management
- **Tokio**: Async runtime for handling concurrent operations
- **Serde**: Serialization/deserialization of Docker API data
### Frontend
- **React**: UI component library
- **TypeScript**: Type-safe development
- **Tailwind CSS**: Utility-first styling
- **shadcn/ui**: Modern component library
- **Lucide Icons**: Beautiful, consistent iconography
## 💡 Key Implementation Details
### Container Management
The core container management functionality is implemented using Bollard's Docker API client:
```rust
#[tauri::command]
async fn list_containers(state: State<'_, AppState>) -> Result, CommandError> {
let docker = &state.docker;
let containers = docker
.list_containers(Some(ListContainersOptions:: {
all: true,
..Default::default()
}))
.await
.map_err(|e| CommandError::DockerError(e.to_string()))?;
let result = containers
.into_iter()
.map(|item| Container {
name: item.names.and_then(|names| {
names
.first()
.map(|name| name.strip_prefix('/').unwrap_or(name).to_owned())
}),
status: item.status,
state: item.state,
ports: item
.ports
.map(|ports| ports.into_iter().filter_map(|port| port.ip).collect()),
})
.collect();
Ok(result)
}
```
### Real-time Container Logs
Implemented streaming logs with proper error handling:
```rust
#[tauri::command]
async fn emit_logs(
state: State<'_, AppState>,
container_name: &str,
on_event: Channel,
) -> Result<(), CommandError> {
let docker = &state.docker;
let options = Some(LogsOptions:: {
stdout: true,
stderr: true,
tail: "all".parse().unwrap(),
..Default::default()
});
let mut logs_stream = docker.logs(container_name, options);
while let Some(log_result) = logs_stream.next().await {
match log_result {
Ok(log) => {
on_event.send(log.to_string())?;
}
Err(e) => {
return Err(CommandError::UnexpectedError(format!(
"Failed to fetch logs: {}",
e
)));
}
}
}
Ok(())
}
```
## 🏗️ Architecture
The application follows a clean architecture pattern:
```
src/
├── main.rs # Application entry point
├── error.rs # Error handling
├── payload/ # Data structures
├── mod.rs
└── types.rs
```
## 🚦 Getting Started
### Prerequisites
- Rust 1.70 or higher
- Node.js 16 or higher
- Docker Engine running on your system
### Installation
1. Clone the repository:
```bash
git clone https://github.com/omniflare/docker-vue.git
cd docker-vue
```
2. Install dependencies:
```bash
# Install Rust dependencies
cargo install tauri-cli
# Install frontend dependencies
cd src-tauri
yarn install
```
3. Run the development version:
```bash
cargo tauri dev
```
4. Build for production:
```bash
cargo tauri build
```
## 🤝 Contributing
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
## 📜 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgments
- [Tauri](https://tauri.app/) for providing the framework that makes this possible
- [Bollard](https://github.com/fussybeaver/bollard) for the excellent Docker API implementation
- [shadcn/ui](https://ui.shadcn.com/) for the beautiful component library
- The Docker community for inspiration and support
## 📫 Contact
For questions and support, please open an issue in the GitHub repository.
---
Made with ❤️ for the Linux community by github.com/omniflare