Colimator 🐳

Colimator is a lightweight, native desktop GUI for managing Colima and Docker containers on macOS. Built with Kotlin Multiplatform and Compose Desktop, it offers a high-performance, resource-efficient alternative to resource-heavy Electron-based solutions.

🚀 Features

Current Features

VM Management:
- Real-time status tracking of the Colima Virtual Machine.
- One-click Start, Stop, and Restart controls.
- Profile management (switch between different Colima profiles).
Container Management:
- List active and stopped containers.
- Start, Stop, and Delete containers.
- View container details (Status, Ports, Image, ID).
- Container Inspection: Detailed container info with Overview and raw JSON views.
- Embedded Terminal: Direct shell access into running containers via docker exec.
- Log Streaming: Real-time container log viewing with ANSI color support.
Image Management:
- List local Docker images.
- Sort images by name or size.
- Delete unused images.
System Integration:
- Native macOS system tray icon (Control app visibility and quick actions).
- Checks for colima and docker dependencies on startup.
User Experience:
- Modern Material Design 3 interface.
- Developer-focused Dark Mode.
- Native performance (JVM-based, low RAM overhead).
Advanced Configuration:
- GUI editor for Colima profile settings (CPU cores, Memory, Disk size).
- Visual feedback during profile start/stop operations.

Planned Features

Volume Management: List and manage Docker volumes.

📸 Screenshots

Dashboard: Real-time VM status and quick actions

Containers: Manage your Docker containers

Images: View and manage local Docker images

Profiles: Switch between Colima contexts

Info: Detailed container inspection with Overview and Raw JSON views

Logs: Real-time container log streaming with ANSI color support

Shell: Embedded terminal for direct container access

Configuration: Customize CPU, memory, and disk settings for Colima profiles

🛠 Tech Stack

Language: Kotlin 2.x
UI Framework: Compose Multiplatform (Desktop)
Runtime: JDK 25 (targeting JVM 21 bytecode)
Build System: Gradle 9.x
Architecture: MVVM (Model-View-ViewModel)

📋 Prerequisites

Before running Colimator, ensure you have the following installed on your macOS system:

Colima: The container runtime.
```
brew install colima
```
Docker Client: The CLI tool to interact with the runtime.
```
brew install docker
```
Java Development Kit (JDK): JDK 21 or higher is required to run the application.

🏃‍♂️ Getting Started

Running Locally

Clone the repository:

git clone https://github.com/yourusername/colimator.git
cd colimator

Run the application:
```
./gradlew run
```
Note: The first run may take a moment to download dependencies.

Building the Installer

To create a standalone .dmg installer for macOS:

./gradlew packageReleaseDmg

The installer will be generated in composeApp/build/compose/binaries/main/dmg/.

🏗 Project Structure

composeApp/src/
├── commonMain/kotlin/com/colimator/
│   ├── App.kt                    # Main application entry & navigation
│   ├── service/                  # Business logic & CLI wrappers (ColimaService, DockerService)
│   ├── ui/                       # Compose UI screens (Dashboard, Containers, Images)
│   ├── viewmodel/                # ViewModels for state management
│   └── domain/                   # Domain models
└── desktopMain/kotlin/com/colimator/
    ├── main.kt                   # Desktop entry point
    └── service/                  # Desktop-specific implementations (e.g., JvmShellExecutor)

🤝 Contributing

Contributions are welcome! Please follow these steps:

Fork the repository.
Create a feature branch (git checkout -b feature/amazing-feature).
Commit your changes (git commit -m 'Add some amazing feature').
Push to the branch (git push origin feature/amazing-feature).
Open a Pull Request.

📄 License

This project is licensed under the MIT License

Built with ❤️ for the developer community.

Colimator

Install / Use

README