Unsloth is an open-source AI platform for running and training open models locally. It combines Unsloth Studio, a graphical interface for running and training models, with Unsloth Core, a code-based library for fine-tuning and machine learning workflows. It supports language, vision, audio, embedding, and diffusion models across Windows, Linux, WSL, and macOS.

The project is particularly focused on making model fine-tuning more efficient by reducing memory usage and improving training performance. It can also run local models and connect them to coding agents and other tools.

Features

Unsloth provides a graphical environment for downloading, running, and training open models. Users can search for models, run them locally, fine-tune them, and export the resulting models to formats such as GGUF and safetensors.

Key features include:

  • Local LLM inference

  • LLM fine-tuning

  • Vision and multimodal models

  • Audio models

  • Embedding models

  • Diffusion models

  • GGUF support

  • MLX support

  • LoRA and other fine-tuning workflows

  • Model export

  • RAG

  • Web search

  • Tool calling

  • Code execution

  • MCP support

  • Multi-GPU support

  • Claude Code integration

  • OpenAI Codex integration

  • OpenCode integration

  • Docker support

  • Self-hosted web interface

  • Python API and notebooks

Unsloth Start can connect local models to supported AI coding agents, allowing tools such as Claude Code and Codex to use models running through Unsloth.

The platform also supports several hardware backends. The project lists NVIDIA, AMD, Intel, CPU, and Vulkan support, although capabilities differ depending on the hardware and workload.

Download Unsloth v0.1.920-beta - Software Mirrors

Unsloth v0.1.920-beta for Windows

Unsloth-Desktop-Windows.exe | 21.15 MB

Unsloth-Desktop-Windows-ARM64.exe | 20.53 MB

Unsloth v0.1.920-beta for macOS

Unsloth-Desktop-MacOS.dmg | 21.6 MB

Unsloth v0.1.920-beta for Linux

Unsloth-Desktop-Ubuntu.deb | 23.02 MB

Unsloth-Desktop-Ubuntu-ARM64.deb | 22.78 MB

Unsloth-Desktop-Linux.AppImage | 170.05 MB

Others Download related to Unsloth v0.1.920-beta

Unsloth-Desktop-ARM64.app.tar.gz | 21.39 MB

Unsloth v0.1.920-beta Source Code

Unsloth v0.1.920-beta Source code (zip)

Unsloth v0.1.920-beta Source code (tar.gz)

Unsloth v0.1.920-beta Release Notes:

AMD NPU support gets a big update in Unsloth: Q4NX models you convert now load on the NPU, and every NPU model shows whether it runs. Also new: LTX-2.5 and MOSS-Image LoRA training, NVIDIA Cosmos3 FP8 video and scheduled tasks that reply in a chat.

Highlights

  • AMD NPU support - See guide and official AMD blog - NPUs are 2-4x more efficient per joule per token vs GPUs
  • Faster images on Strix Halo - FLUX.3 Klein up to 28% faster per step on Windows
  • LTX-2.5 and MOSS-Image LoRA training in Unsloth
  • Diffusion LoRA training up to 42% faster per step, and now on T4 GPUs too
  • NVIDIA Cosmos3 Nano-FP8 and Edge-FP8 video models now load
  • Scheduled tasks in a chat that reply right in that chat

AMD NPU

  • Q4NX models you convert on the Export page now show as Converted in the NPU model list and load on the NPU, text only.
  • Q4NX conversion moves to its own Convert to Q4NX tab on the Export page, next to LLM and Diffusion LoRA.
  • Each NPU model is tagged Runs on NPU, Convert, then runs, Converts, won't run or Not supported, read from your installed FastFlowLM, so new models such as LFM3 are no longer hidden.
  • Q4NX conversion now refuses GGUF quants that would load as garbage, such as Qwen3.5 from a Q4_0 GGUF answering only with slashes, and moves on to the next quant.
  • The composer model picker now uses the Model hub's NPU names and order, such as Qwen3.6-35B-A3B-NPU2, with the FastFlowLM logo.
  • The OpenAI-compatible API, unsloth run and unsloth chat accept the NPU model name the app shows, or its FastFlowLM/ repo, instead of only the lemonade: id.
  • The new unsloth list-npu-models lists NPU models with their size, download state and whether they fit your NPU's memory.
  • unsloth chat no longer reloads an NPU model that unsloth run already loaded with a set --context-length.
  • Deep research works on NPU models instead of failing with HTTP 400 or "Local model never started producing output".

AMD GPUs

  • On Windows with Strix Halo, FLUX.3 Klein INT8 runs up to 28% faster per step and Qwen-Image-2.1 up to 23% faster.
  • On Strix Halo, Qwen-Image-2.1 and Wan now try INT8 attention automatically, and on Linux FLUX.3 Klein INT8 is now as fast as bf16.
  • On Strix Halo with Vulkan, Z-Image images finish about 21% faster with much lower peak memory.
  • On a 16 GB Vulkan card with a CPU PyTorch, MiniMax-H3-Image no longer runs out of system memory on the first image.
  • Packed training on ROCm now uses flash varlen attention, so packing is faster than padding.
  • On Windows, the GPU monitor now shows utilization and temperature for AMD GPUs, and Smart App Control no longer shows a blocked hipInfo.exe popup.
  • On Windows, setup now stops with an error when ROCm PyTorch fails to install on a supported AMD GPU, instead of quietly falling back to CPU.

Images + video

  • Load NVIDIA's Cosmos3-Nano-FP8 and Cosmos3-Edge-FP8 on the Video page, with no extra NVIDIA package.
  • Train LoRAs for LTX-2.5 and MOSS-Image, and load them back on the Video and Images pages.
  • Diffusion LoRA training runs 20 to 42% faster per step when the GPU has room to keep activations.
  • FLUX.2-klein, Z-Image and Wan 2.2 5B LoRAs now train on T4 and other GPUs without bf16.
  • MiniMax-H3-Image now renders on 8 GB GPUs, and the LTX-2 video decoder runs about 1.7 to 1.8x faster.

Chat + Desktop

  • Add a scheduled task from a chat's title menu, and every run replies in that chat.
  • The Translate page has a new layout with language tabs, side-by-side panes and document or image uploads.
  • On Linux, computer use now works in Wayland sessions through the desktop portal, not just X11.
  • Owners can set trusted folders in Settings > Security that Python and Terminal tools can read and run from without asking.
  • Videos a model writes in the sandbox now play inline in chat.

Coding agents + API

  • Each model alias in Settings > API can have its own context length, KV cache type and speculative decoding.
  • /v1/chat/completions now applies a grammar or json_schema instead of silently ignoring it.
  • Chats allow 50 tool calls per message by default, with no cap while MCP is on.

Training

  • QLoRA training is up to 25% faster by keeping dequantized base weights in spare VRAM, as on Llama-3.1-8B on L4.
  • bf16 full fine-tuning now uses stochastic rounding by default, so small updates are no longer lost.

Mac

  • MLX models get the same Run settings as GGUF where MLX supports them.
  • Ollama MLX-format tags such as gemma4:-mlx and qwen3.6:-mlx now show in the model picker and load, with their bundled drafters.

Thanks to our contributors for this release:

@danielhanchen, @LeoBorcherding, @Lyxot, @Imagineer99, @Etherll, @DimitriChrysafis, @shimmyshimmer, @NilayYadav, @oobabooga, @Max-Reisinger, @vineethsaivs, @lonexreb, @debojyoti-dev, @bezabyte, @wasimysaid, @Lluczel, @BlagonravovSL, @0xalkinun, @MohammadHijjawi97

Performance and Compatibility

Performance is one of Unsloth's main purposes. Its training optimizations are designed to reduce memory requirements and speed up fine-tuning compared with conventional training workflows.

Actual performance depends heavily on the model, quantization, GPU, available VRAM, dataset, batch size, and training configuration. The project supports multi-GPU setups and provides specialized guidance for newer NVIDIA hardware, AMD GPUs, Intel GPUs, and Apple silicon.

Unsloth Studio can run on Windows, Linux, WSL, and macOS. The project also provides native desktop packages for Windows, macOS, and Linux, while the Studio interface can be installed separately and accessed through a local web interface.

macOS users can run models through MLX and GGUF, while supported Apple Silicon systems can also perform training workflows. NVIDIA GPUs provide the broadest support for training workloads, while AMD and Intel support varies by backend and feature.

Because Unsloth works with local models, storage requirements can become significant. Model weights, datasets, checkpoints, caches, and exported models can consume substantially more storage than the application itself.

System Requirements

Unsloth does not have one fixed hardware requirement because different workloads have very different resource requirements.

Supported platforms include:

  • Windows

  • Linux

  • WSL

  • macOS

  • NVIDIA GPUs

  • AMD GPUs

  • Intel GPUs

  • Apple Silicon

  • CPU-only operation for supported workloads

For the code-based installation, the current documentation uses Python 3.13 with uv for Linux, WSL, and Windows installations.

GPU training requires a compatible backend and sufficient memory for the selected model and training configuration. Larger models generally require more VRAM or system memory, while quantized models can substantially reduce the memory requirement.

Docker is also supported, with official images available for different environments and GPU configurations.

Pros and Cons

Pros

  • Free and open source

  • Local model inference

  • Fine-tuning support

  • Memory-efficient training optimizations

  • Supports multiple model types

  • GGUF support

  • MLX support

  • RAG capabilities

  • MCP support

  • Tool calling

  • Code execution

  • Multi-GPU support

  • Windows, Linux, WSL, and macOS support

  • NVIDIA, AMD, Intel, and CPU support

  • Apple Silicon support

  • Docker support

  • Desktop application

  • Web interface

  • Python-based workflows

  • Supports AI coding agents

Cons

  • Hardware requirements vary significantly by model

  • Large models require substantial VRAM or system memory

  • Training workflows can be technically complex

  • Different hardware backends do not provide identical capabilities

  • Model files and training datasets can consume considerable storage

  • Some advanced workflows require command-line or Python knowledge

How to Install

The simplest option is Unsloth Desktop. The project provides native packages for Windows, macOS, and Linux. Linux users can choose DEB or AppImage packages, while macOS and Windows have dedicated installers.

For Unsloth Studio, macOS, Linux, and WSL can use:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows can use:

irm https://unsloth.ai/install.ps1 | iex

After installation, start the Studio interface with:

unsloth studio

The interface runs locally and can be accessed through a web browser.

For developers who prefer the Python package, Unsloth Core can be installed inside a virtual environment. The project currently recommends using uv to create the environment and install Unsloth with automatic PyTorch backend selection.

Docker is another option for users who prefer an isolated environment or need a reproducible setup.

Final Verdict

Unsloth is more than a fine-tuning library. Its current ecosystem combines local model inference, training, model conversion, RAG, tool calling, AI agents, and a graphical Studio interface into a single open-source platform.

Its biggest strength is flexibility. Users can start with the desktop application and local models, then move to Python-based fine-tuning or Docker when they need more control. Support for multiple hardware platforms also makes it useful across a wider range of systems, although the available capabilities vary between backends.

The main limitation is complexity. Unsloth is aimed at users working with local AI models rather than people looking for a simple chatbot. Model size, VRAM, training configuration, and hardware compatibility all have a significant impact on the experience.

Unsloth v0.1.920-beta
Free
Software Informations:
Developer:

Operating System:
Windows / macOS / Linux
Date Added:
2026-11-20T03:07:20.096Z

Kiri is a lightweight, open-source container runtime designed as an alternative to Docker Desktop and OrbStack. Written in Rust, it runs Docker containers through a compact Linux virtual machine on macOS and Windows, while using the host Linux kernel directly on Linux.

Its main selling points are fast container startup, low idle resource consumption, and compatibility with familiar Docker tools. It works with the Docker CLI, Docker Compose, and Buildx, so developers can continue using much of their existing container workflow.

Kiri also goes beyond basic container management with a graphical interface, local development domains, single-node Kubernetes, lightweight Linux machines, and container migration from other desktop runtimes.

Features

Lightweight Docker-Compatible Runtime

Kiri implements the Docker Engine API, allowing existing Docker tools to communicate with its runtime.

It supports common Docker operations, including:

  • Container creation, execution, inspection, and removal.

  • Container logs and interactive shell access.

  • Image pulling, pushing, tagging, and removal.

  • Volume and network management.

  • Resource limits for CPU, memory, and processes.

  • Container security options and capabilities.

  • Docker Compose project deployment.

The first launch automatically configures a dedicated kiri Docker context. This lets users switch between Kiri and an existing Docker Engine without replacing their current configuration.

For example:

docker --context kiri run --rm alpine echo hello

docker --context kiri compose up -d

Users can also execute Docker commands directly through the kiri CLI.

Fast Startup and Low Resource Consumption

Performance is one of Kiri's main selling points. The project reports container startup and removal in approximately 2.5 milliseconds through the Docker Engine API, compared with 213 milliseconds for Docker Desktop in its own benchmark.

It also reports approximately 15 MB of daemon memory usage while idle. The Linux VM automatically sleeps after 60 seconds without activity and can wake in approximately 0.15 seconds.

These are developer-reported benchmark results rather than independent performance measurements, but they demonstrate the project's focus on minimizing runtime overhead.

Docker Compose and Buildx Support

Kiri supports Docker Compose, making it possible to deploy multi-container applications using existing YAML configurations.

Supported operations include:

  • Deploying and removing Compose projects.

  • Starting and stopping services.

  • Viewing project logs.

  • Executing commands inside containers.

  • Managing multiple networks.

  • Building images through BuildKit and Buildx.

BuildKit runs inside a Kiri-managed container using the Buildx Docker-container driver.

There is an important limitation: host-gateway is not supported by BuildKit's Docker-container driver in this configuration. The project documents workarounds, including specifying the gateway address directly or using the legacy Docker builder where appropriate.

Graphical Container Management

Kiri includes a native desktop interface for managing container environments without relying entirely on terminal commands.

The interface provides dedicated views for:

  • Containers and their status.

  • Images and image layers.

  • Volumes and networks.

  • Compose projects.

  • Container logs and processes.

  • Container files and configuration.

  • Resource usage and runtime settings.

Users can inspect container files, preview content, save files to their local Downloads directory, and open directories through the host file manager.

Kiri also provides a menu bar or system tray interface for checking runtime status and controlling the engine.

Local Development Domains and HTTPS

Kiri can assign local domains to containers, making development services easier to access.

For example, a container named web can be reached through:

http://web.kiri.local
https://web.kiri.local

Compose services can also receive project-specific names.

Kiri includes its own certificate authority for local HTTPS connections. This eliminates the need to configure a separate reverse proxy and manually generate certificates for every development service.

The application also supports .localhost domains without requiring the additional domain configuration.

Public Container Sharing

Kiri includes a sharing feature that exposes a container through a public HTTPS address.

This is useful for demonstrating local applications, sharing development environments, testing webhooks, and temporarily making a service accessible outside the local network.

It provides functionality similar to tunneling services such as ngrok, without requiring users to configure traditional router port forwarding.

Public sharing depends on Kiri's cloud infrastructure, so it is different from running a completely independent, self-hosted tunnel server.

Built-in Kubernetes

Kiri can create a single-node Kubernetes cluster using k3s.

Start the cluster with:

kiri k8s start

The cluster is configured as the kiri kubectl context, allowing users to work with Kubernetes through familiar commands.

Kubernetes LoadBalancer services can be published on localhost. This makes Kiri useful for developers who need to test Kubernetes workloads without maintaining a separate cluster.

It is particularly convenient for local development, experimentation, and learning Kubernetes.

Lightweight Linux Machines

Beyond containers, Kiri can create lightweight Linux machines.

For example:

kiri machine create dev --distro ubuntu
kiri machine shell dev

These machines provide a separate Linux environment with a user account and sudo access. Host directories can also be made available inside the machine.

This is useful for testing Linux applications, running development tools, and maintaining isolated environments without installing a full virtual machine manager.

USB Device Passthrough

Kiri supports USB device passthrough, currently marked as beta.

Users can attach compatible USB devices to containers, including:

  • Serial adapters.

  • Zigbee USB sticks.

  • Development boards.

  • Other supported USB peripherals.

The application displays the device path inside the Linux environment and provides the corresponding Docker --device configuration.

This is particularly useful for developers working with embedded systems and hardware projects.

Import from Existing Container Runtimes

Kiri provides an import command for migrating existing containers, images, and volumes from Docker Desktop or OrbStack.

This reduces the amount of manual work involved in switching container environments.

Users can bring existing development workloads into Kiri rather than recreating every container and downloading every image again.

Multi-Platform Support

Kiri supports macOS, Windows, and Linux.

It also supports running AMD64 container images on Apple Silicon through Rosetta, allowing users to work with software images that do not have native ARM64 builds.

The project supports multiple interface languages, making it accessible to developers across different regions.

Download Kiri 0.2.2 - Lightweight Replacement for Docker Desktop - Software Mirrors

Kiri 0.2.2 for Windows

Kiri-0.2.2-arm64.msi | ARM · 56 MB

Kiri-0.2.2-x86_64.msi | x64 · 62 MB

Kiri 0.2.2 for macOS

Kiri-0.2.2-arm64.dmg | Apple silicon · 51 MB

Kiri-0.2.2-x86_64.dmg | Intel · 61 MB

Kiri 0.2.2 for Linux

kiri-lite_0.2.2_amd64.deb | Debian, Ubuntu · x86-64 · engine only · 2.9 MB

kiri-lite_0.2.2_arm64.deb | Debian, Ubuntu · ARM · engine only · 2.7 MB

kiri_0.2.2_amd64.deb | Debian, Ubuntu · x86-64 · 52 MB

kiri_0.2.2_arm64.deb | Debian, Ubuntu · ARM · 43 MB

kiri-0.2.2-1.aarch64.rpm | Fedora, RHEL · ARM · 39 MB

kiri-0.2.2-1.x86_64.rpm | Fedora, RHEL · x86-64 · 49 MB

kiri-lite-0.2.2-1.aarch64.rpm | Fedora, RHEL · ARM · engine only · 2.4 MB

kiri-lite-0.2.2-1.x86_64.rpm | Fedora, RHEL · x86-64 · engine only · 2.7 MB

Kiri 0.2.2 Release Notes:

Security

This release fixes several security problems, most of them reported to us privately. Update now. Details are in the advisories on the repository's Security tab.

  • An image can no longer reach files on your Mac that you didn't share. The Linux VM is now given /Users, /Volumes and /private (as Docker Desktop shares by default), not the whole disk, and mount settings that come from an image are checked more strictly.
  • A container's working directory always stays inside the container, and so does the folder Kiri makes for it when it is missing.
  • A new volume is filled without following links inside it, so a container sharing the volume can't send the copy somewhere else.
  • A malformed DNS query from a container can no longer stop the engine.
  • Mac: containers can't reach other containers through the domain router (*.kiri.localhost), and its "not found" page lists your running containers only when asked by one of your own machine's names.
  • Seccomp profiles are applied, and the default filter matches Docker's.
  • Linux and WSL: containers are firewalled on kernels before 6.3, and reach the internet there.
  • An --init container's first process keeps none of the engine's open files.

New

  • Compose has its own section in the window.
  • Install with Homebrew: brew install --cask libracoder/kiri/kiri.
  • Every menu in the window can be searched: type to filter fonts and other long lists, with the arrow keys, Enter and Escape.
  • Windows: Settings → Import brings images, volumes and containers over from Docker Desktop.
  • Loop devices work in containers (losetup, disk images).
  • Container files in Finder show volumes and bind mounts.

Fixed and improved

  • Compose 5.7 and later attach again: docker compose up and docker compose logs -f show output.
  • Testcontainers for .NET, MongoDB and LocalStack start: Kiri closes a connection when the client asks it to, answers exec and attach as Docker does, joins a container only to its own network, and a file copied in straight after a start is there.
  • docker exec straight after a start finds the image's users, and a start that fills a new volume no longer holds up every other container.
  • Saves made on the Mac reach file watchers in containers, so hot reload works in bind-mounted folders.
  • always and unless-stopped containers come back after the VM crashes, and Kiri restarts on the new version after every update.
  • A published TCP connection stays open however long it is quiet.
  • Pulling several images at once can no longer damage the image list, and a damaged one is repaired. A damaged container list no longer costs containers their logs, files or volumes.
  • A named pipe, or a program that never stops writing, no longer holds up the engine.
  • Images with hard links to absolute symlinks unpack (Supabase's PostgreSQL image).
  • k3d finds its nodes: the name filter is a regular expression, as in Docker.
  • Images list newest first, and a missing working directory is made for non-root and read-only containers.
  • A tmpfs volume keeps its owner and mode.
  • Image update checkers (Watchtower, Arcane) work: Kiri answers GET /distribution/{name}/json.
  • docker inspect reports a container's port bindings and exposed ports.
  • Image names with encoded characters resolve (mongodb%2Fmongodb-atlas-local).
  • docker cp never mounts a container's root twice, and containers start and commit correctly on kernels with overlayfs index on (Arch, CachyOS).
  • Signals only reach running processes, and a failed start leaves no DNS name behind.
  • Import brings volumes, containers that share a network and digest-pinned images across, leaves a volume in use alone, and says plainly when OrbStack or Docker Desktop isn't running.
  • Windows: Docker works again after WSL restarts, launching Kiri at login no longer undoes a Stop, and the window opens whatever the page's size.
  • Mac: ⌘C, ⌘V, ⌘X, ⌘A and ⌘Z work in the window's text fields, the traffic lights stay in the strip after switching themes, and opening Kiri from Finder no longer quits silently when a shell profile is a link to nothing.
  • Mac: a first-launch step that fails no longer closes Kiri. It waits in the setup checklist with its error and Try again, and the window works meanwhile.
  • Linux: an engine restart cleans up containers whose cgroup systemd already removed.

Performance and Compatibility

Kiri is written in Rust and uses a custom lightweight Linux kernel and guest agent.

On macOS and Windows, containers run inside a dedicated Linux environment. On Linux, Kiri uses the host kernel directly instead of creating another virtual machine.

Its architecture avoids the conventional combination of Docker Engine, containerd, runc, and per-container shims. Instead, its guest agent creates containers using Linux namespaces and cgroups.

The project reports significantly faster container startup than Docker Desktop and OrbStack in its own benchmarks. Actual performance will depend on hardware, storage, workload, filesystem operations, and network configuration.

Platform support includes:

  • macOS: Apple Silicon and Intel processors, macOS 14 or later.

  • Windows: Windows 10 and 11 on x86-64 and ARM, using WSL 2.

  • Linux: x86-64 and ARM64, with DEB and RPM packages tested on Ubuntu and Fedora.

One important consideration is that Kiri is still a relatively young container runtime. Although it supports many Docker commands and Compose workflows, it should not automatically be considered a complete replacement for every Docker Engine feature. Users with specialized networking, storage, or BuildKit requirements should check the compatibility documentation before migrating production workflows.

System Requirements

macOS

  • macOS 14 or later.

  • Apple Silicon or Intel processor.

  • Compatible virtualization support.

  • Sufficient memory and storage for the selected containers.

Windows

  • Windows 10 or Windows 11.

  • x86-64 or ARM64 processor.

  • Windows Subsystem for Linux 2.

  • Hardware virtualization enabled.

  • Sufficient memory and storage for container workloads.

Linux

  • 64-bit Linux distribution.

  • x86-64 or ARM64 processor.

  • Compatible Linux kernel and cgroup support.

  • DEB or RPM package installation.

  • Appropriate permissions for container management.

Actual resource requirements depend on the number of running containers, images, volumes, and Kubernetes workloads.

Pros and Cons

Pros

  • Free and open-source under Apache 2.0.

  • Available for macOS, Windows, and Linux.

  • Lightweight runtime written in Rust.

  • Very fast container startup according to project benchmarks.

  • Low idle memory consumption.

  • Compatible with Docker CLI and Docker Compose.

  • Supports Buildx and BuildKit.

  • Native graphical interface for container management.

  • Local development domains with HTTPS.

  • Public HTTPS sharing for containers.

  • Built-in single-node Kubernetes using k3s.

  • Supports lightweight Linux machines.

  • USB device passthrough.

  • AMD64 image support on Apple Silicon through Rosetta.

  • Import functionality for Docker Desktop and OrbStack environments.

Cons

  • Relatively young project with an evolving feature set.

  • Not fully compatible with every Docker Engine feature.

  • Windows relies on WSL 2.

  • BuildKit has a documented host-gateway limitation.

  • USB passthrough is still beta.

  • Public sharing depends on external Kiri infrastructure.

  • Advanced Kubernetes and container workloads may require additional resources.

How to Install

Kiri provides graphical installers and Linux packages for its supported platforms.

macOS

Download the appropriate DMG installer for Apple Silicon or Intel Macs.

After installation, open Kiri. The application configures its Docker context automatically.

Verify the installation:

docker --context kiri run --rm alpine echo hello

Windows

Download the MSI installer for x86-64 or ARM64.

Kiri uses WSL 2 to provide its Linux container environment. Ensure virtualization and WSL 2 are available before installation.

After installation, open Kiri and use its configured Docker context:

docker --context kiri run --rm alpine echo hello

Ubuntu and Debian

Download the appropriate DEB package from the official release page.

Install it with:

sudo apt install ./kiri_*_amd64.deb

For ARM64 systems, select the corresponding ARM64 package.

Fedora and Other RPM-Based Distributions

Download the RPM package and install it using:

sudo dnf install ./kiri-*.rpm

After installation, open Kiri to complete the initial setup.

Verify Docker Compatibility

Run a test container:

docker --context kiri run --rm alpine echo hello

Check the active context:

docker context ls

Kiri also provides a command-line interface for managing its runtime directly:

kiri --help

Final Verdict

Kiri is an impressive lightweight alternative to Docker Desktop and OrbStack, particularly for developers who want a faster and less resource-intensive container environment.

Its compatibility with Docker CLI and Compose makes migration relatively straightforward, while features such as local HTTPS domains, public container sharing, Kubernetes, Linux machines, and USB passthrough give it functionality beyond a basic container runtime.

The Rust-based architecture and ability to run directly on the Linux kernel are also notable technical advantages. Its low idle resource consumption makes it attractive for development workstations where Docker Desktop can otherwise consume unnecessary resources.

However, Kiri is still evolving, and some Docker compatibility limitations deserve consideration before replacing an established production development environment. Its reliance on WSL 2 on Windows and external infrastructure for public sharing are additional factors to evaluate.

Overall, Kiri is a promising choice for developers looking for a modern, lightweight, and cross-platform Docker Desktop alternative.

Sources


Kiri 0.2.2 - Lightweight Replacement for Docker Desktop
Free
Software Informations:
Developer:

Operating System:
Windows / macOS / Linux
Date Added:
2026-11-20T03:07:19.944Z

Arcane is a self-hosted container management platform that provides a modern web interface for managing Docker environments. Developed by the GetArcane team, it integrates container management, Docker Compose deployments, image handling, backups, and automated updates into a single dashboard.

Instead of relying exclusively on terminal commands, users can inspect containers, edit Compose files, monitor resource usage, manage volumes, and deploy applications—all through a web browser. Arcane also supports remote hosts, enabling the management of multiple Docker environments from a centralized installation.

Beyond Docker, Arcane has expanded its capabilities to include native Podman management and Docker Swarm support. This makes it an attractive option for home-lab enthusiasts, developers, and administrators who manage self-hosted infrastructure.

Features

Docker Container Management

Arcane provides a centralized interface for managing Docker containers. Users can inspect running and stopped containers, monitor resource consumption, view logs, and perform common lifecycle operations.

Available management capabilities include:

  • Start, stop, restart, and remove containers.

  • Inspect container configuration and metadata.

  • Monitor CPU and memory usage.

  • View container logs and activity.

  • Access container processes.

  • Manage container environment variables and settings.

  • Identify available image updates.

These features make routine container administration easier without requiring users to remember every Docker command.

Docker Compose Project Management

One of Arcane's strongest features is its Docker Compose project management system.

Users can create projects directly from the dashboard, write or edit Compose YAML files, configure environment variables, and deploy multiple services together.

The project workspace includes a file editor with support for managing configuration files, folders, and .env files. Existing Compose projects can also be discovered from configured directories.

Project operations include:

  • Create and deploy Compose projects.

  • Start, stop, restart, and redeploy services.

  • Edit Compose files and environment variables.

  • Build images directly from project configurations.

  • Manage project files through a browser-based workspace.

  • Organize projects using tags.

  • Monitor deployment output and activity.

Arcane also supports Git synchronization. Projects can pull configuration from repositories, push changes back to Git, or synchronize in both directions. This is useful for maintaining infrastructure configurations under version control.

Image Management and Updates

Arcane provides tools for managing Docker images and monitoring available updates.

Users can browse local images, inspect image details, pull new versions, remove unused images, and review image update information.

Its automatic update functionality can periodically check for newer image versions and apply configured update strategies. Users can also control update behavior for individual containers and projects.

Additional capabilities include:

  • Registry browsing and image tag discovery.

  • Image building from Compose projects.

  • Image update notifications.

  • Automatic image updates.

  • Image pruning and cleanup.

  • Digest-based update strategies.

  • Configurable update schedules.

These features help administrators maintain container environments without manually checking every image.

Backup and Restore

Arcane includes backup functionality for protecting container-related data and configurations.

It supports backups of Docker volumes, project files, and system-level configuration. Backup destinations can include local storage and compatible remote storage services.

The integration with Rustic provides additional backup and repository management capabilities.

Users can configure backup schedules and retention policies to reduce manual maintenance. This is particularly useful for homelabs and self-hosted applications that store important data in Docker volumes.

A backup strategy should still be tested through actual restoration procedures. Having a successful backup job does not automatically guarantee that an application can be recovered correctly.

Remote Docker Management

Arcane can manage multiple Docker hosts through its remote agent architecture.

A central Arcane Manager communicates with lightweight agents installed on remote machines. These agents connect outward to the manager, so they do not need publicly exposed inbound ports.

This architecture is useful for managing servers located behind NAT, firewalls, or different network environments.

Administrators can use one dashboard to monitor and manage containers across multiple hosts instead of maintaining separate management interfaces for each server.

The agent architecture also supports secure communication options, including mutual TLS authentication.

Native Podman Support

Arcane is no longer limited to Docker. It also supports native Podman management, including rootless Podman environments.

Its Podman interface provides access to:

  • Containers and images.

  • Volumes and networks.

  • Pods.

  • Quadlets.

  • Kubernetes YAML.

  • Podman secrets.

  • Podman automatic updates.

Rootless Podman support is particularly useful for users who want container management without running their workloads as root.

This makes Arcane a more flexible option for environments that use Podman instead of Docker.

Docker Swarm Management

Arcane also provides management capabilities for Docker Swarm environments.

Its documentation covers cluster administration, workloads, nodes, agents, configurations, and secrets.

This allows administrators to manage more than standalone containers and Compose projects through the same platform.

For users running distributed container workloads, having these tools available in one interface can simplify infrastructure operations.

Security and Vulnerability Scanning

Arcane includes container image vulnerability scanning through Trivy.

The security dashboard helps administrators identify vulnerable packages, review findings, and prioritize remediation based on risk.

Its security features include:

  • Scheduled vulnerability scans.

  • CVE discovery and severity reporting.

  • Image risk scoring.

  • Vulnerability filtering and export.

  • Available fix information.

  • Image patching through Copacetic for supported scenarios.

The ability to patch fixable operating-system package vulnerabilities without waiting for an upstream image release is particularly interesting.

However, image patching has additional requirements, including Docker's containerd image store. Administrators should understand the migration implications before enabling it on production hosts.

Dashboard, Monitoring, and Notifications

Arcane provides a customizable dashboard for monitoring container environments.

The dashboard uses configurable widgets, allowing users to arrange information according to their preferences.

It can display container status, host resource usage, environment information, and other operational data.

Additional monitoring and integration features include GPU monitoring, OpenTelemetry support, activity tracking, and notifications through supported services.

The activity center provides a centralized view of deployments, updates, backups, and other background operations.

User Management and Authentication

Arcane includes access control features for installations shared by multiple administrators.

Its authentication and authorization capabilities include:

  • User accounts and role-based permissions.

  • OpenID Connect single sign-on.

  • Passkeys and multi-factor authentication.

  • Federated credentials.

  • API access controls.

  • Agent authentication and mutual TLS options.

These features make it more suitable for team environments than basic container dashboards with a single shared login.

Download Arcane v3.1.1 - Modern Docker Management - Software Mirrors

Arcane v3.1.1 - Modern Docker Management for macOS

arcane_darwin_arm64 | 119.65 MB

arcane_darwin_amd64 | 127.72 MB

arcane-cli_darwin_arm64.tar.gz | 9.26 MB

arcane-agent_darwin_arm64 | 94.15 MB

arcane-agent_darwin_amd64 | 102.42 MB

Arcane v3.1.1 - Modern Docker Management for Linux

arcane_linux_riscv64 | 113.88 MB

arcane_linux_armv7 | 117.25 MB

arcane_linux_arm64 | 116.38 MB

arcane_linux_amd64 | 125.3 MB

arcane_linux_386 | 117.51 MB

arcane-cli_linux_riscv64.tar.gz | 9.24 MB

arcane-cli_linux_armv7.tar.gz | 9.18 MB

arcane-cli_linux_arm64.tar.gz | 8.8 MB

arcane-cli_linux_amd64.tar.gz | 9.74 MB

arcane-cli_linux_386.tar.gz | 9.23 MB

arcane-cli_3.1.1_x86_64.apk | 10.03 MB

arcane-cli_3.1.1_x86.apk | 9.44 MB

arcane-cli_3.1.1_riscv64.deb | 9.13 MB

arcane-cli_3.1.1_riscv64.apk | 9.43 MB

arcane-cli_3.1.1_i386.deb | 9.12 MB

arcane-cli_3.1.1_armv7.apk | 9.41 MB

arcane-cli_3.1.1_armhf.deb | 9.07 MB

arcane-cli_3.1.1_arm64.deb | 8.69 MB

arcane-cli_3.1.1_amd64.deb | 9.63 MB

arcane-cli_3.1.1_aarch64.apk | 9.03 MB

arcane-cli-3.1.1-1.x86_64.rpm | 9.9 MB

arcane-cli-3.1.1-1.riscv64.rpm | 9.34 MB

arcane-cli-3.1.1-1.i386.rpm | 9.36 MB

arcane-cli-3.1.1-1.armv7hl.rpm | 9.3 MB

arcane-cli-3.1.1-1.aarch64.rpm | 8.91 MB

arcane-cli-3.1.1-1-x86_64.pkg.tar.zst | 9.43 MB

arcane-cli-3.1.1-1-i686.pkg.tar.zst | 8.85 MB

arcane-cli-3.1.1-1-armv7h.pkg.tar.zst | 8.73 MB

arcane-cli-3.1.1-1-aarch64.pkg.tar.zst | 8.46 MB

arcane-agent_linux_riscv64 | 88.63 MB

arcane-agent_linux_armv7 | 92 MB

arcane-agent_linux_arm64 | 91.06 MB

arcane-agent_linux_amd64 | 100.03 MB

arcane-agent_linux_386 | 92.26 MB

Arcane v3.1.1 - Modern Docker Management Source Code

Arcane v3.1.1 - Modern Docker Management Source code (zip)

Arcane v3.1.1 - Modern Docker Management Source code (tar.gz)

Arcane v3.1.1 - Modern Docker Management Release Notes:

[!NOTE]
This release fixes several backup, container, and project issues, including overlapping scheduled backups now running in turn instead of being skipped. It also includes frontend fixes and refactors, including removing the ky HTTP client and migrating E2E tests to vite-plus.

Backups and volumes

  • Run overlapping scheduled system backups in turn instead of skipping them (#4876) (@neurekadev)
  • Run overlapping scheduled backups of the same volume in turn (#4879) (@neurekadev)
  • Restore a new volume's root owner and mode from the archive (#4887) (@neurekadev)
  • Skip missing volumes in project transfer and archive validation (#4893) (@kmendell)
  • Mount the Rustic CA bundle from the data directory instead of copying it into the container (#4875) (@neurekadev)

Containers, images, and environments

  • Skip update checks for Podman localhost images (#4873) (@kmendell)
  • Clear the pending redeploy when Arcane refuses to redeploy itself (#4905) (@astronaute77)
  • Show unreachable picked environments inline instead of erroring (#4908) (@kmendell)

Projects

  • Support Compose job runs in projects (#4877) (@kmendell)

Frontend

  • Quote download filenames and fix the share download flow (#4871) (@kmendell)
  • Align table row action button and hover corners (#4882) (@kmendell)
  • Align container create and edit page headers (#4892) (@kmendell)
  • Set up frontend telemetry reactively instead of blocking load (#4891) (@kmendell)

Refactors

  • Clean up frontend queries and remove the ky HTTP client (5 commit 4fbe070017b6bc82119aeabd6ee0003dd4544125) (@kmendell)
  • Migrate Playwright E2E tests to the vite-plus test runner (#4896) (@kmendell)

Performance and Compatibility

Arcane is built using Go for its backend and SvelteKit with TypeScript for its web interface. Its architecture separates management operations from remote host execution through dedicated agents.

The application is designed to run as a self-hosted service, typically using Docker Compose. Once deployed, administrators can access its dashboard through a web browser.

Its performance improvements include optimized database queries, caching, background job processing, and virtualized tables for large datasets.

Arcane supports Docker and Podman environments, with additional management capabilities for Docker Swarm. Remote agents allow it to manage multiple machines from a single installation.

One important consideration is Docker socket access. The standard installation mounts /var/run/docker.sock into the Arcane container. This grants extensive control over the Docker host and should be treated as a highly privileged interface. For environments with stricter security requirements, consider using a socket proxy or the documented remote-agent architecture.

Arcane is distributed under the BSD 3-Clause license, making its source code available for inspection, modification, and redistribution under the license terms.

System Requirements

  • Linux server or another supported container host.

  • Docker Engine and Docker Compose for the standard installation.

  • Podman for supported Podman deployments.

  • Persistent storage for application data and configuration.

  • A web browser for accessing the management interface.

  • Network connectivity between the manager and remote agents.

  • Sufficient CPU, RAM, and storage for the number of managed containers and background operations.

Arcane does not specify one universal minimum hardware configuration. Resource requirements depend on the number of environments, containers, projects, vulnerability scans, and backup workloads.

Pros and Cons

Pros

  • Free and open-source under the BSD 3-Clause license.

  • Modern web-based container management interface.

  • Comprehensive Docker container and image management.

  • Full Docker Compose project editor and deployment workflow.

  • Git synchronization for infrastructure configurations.

  • Remote management through lightweight agents.

  • Native Podman and rootless Podman support.

  • Docker Swarm management capabilities.

  • Automated image updates and backup scheduling.

  • Integrated Trivy vulnerability scanning.

  • Image patching through Copacetic for supported configurations.

  • Role-based access control, OIDC, and passkey authentication.

  • Customizable dashboard and activity center.

  • Supports GPU monitoring and OpenTelemetry.

Cons

  • Requires self-hosting and container infrastructure.

  • Standard Docker installation grants extensive privileges through socket access.

  • Some advanced security features require additional configuration.

  • Vulnerability patching has specific Docker storage requirements.

  • Managing large environments can require more resources for scanning, monitoring, and background jobs.

  • Major version upgrades may introduce breaking changes that require migration planning.

How to Install

Arcane provides a Docker Compose installation method and a Linux installation script.

Docker Compose Installation

First, generate an encryption key:

docker run --rm ghcr.io/getarcaneapp/manager:latest \
  /app/arcane generate secret

Create a compose.yaml file:

services:
  arcane:
    image: ghcr.io/getarcaneapp/manager:latest
    container_name: arcane
    ports:
      - "3552:3552"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - arcane-data:/app/data
      - /opt/docker:/opt/docker
    environment:
      - ARCANE_APP_URL=http://localhost:3552
      - PUID=1000
      - PGID=1000
      - ARCANE_ENCRYPTION_KEY=YOUR_GENERATED_KEY
      - ARCANE_PROJECTS_DIRECTORY=/opt/docker
    cgroup: host
    restart: unless-stopped

volumes:
  arcane-data:

Replace YOUR_GENERATED_KEY with the generated encryption key. Adjust the project directory and user IDs according to your environment.

Start Arcane:

docker compose up -d

Open the web interface at:

http://localhost:3552

On first startup, Arcane generates an initial administrator password. Retrieve it using:

docker compose cp arcane:/app/data/initial-admin-password .

Use the generated credentials to sign in and configure your account.

Linux Installation Script

Arcane also provides an installation script that installs Docker and Arcane:

curl -fsSL https://getarcane.app/install.sh | sudo bash

Review the official installation documentation before using the script, especially on systems with an existing Docker installation or customized container configuration.

Final Verdict

Arcane is a comprehensive self-hosted container management platform that goes well beyond basic Docker dashboards. Its combination of container administration, Compose project management, Git synchronization, remote agents, automated updates, backups, and vulnerability scanning makes it a strong option for managing modern container environments.

Native Podman support and Docker Swarm management further expand its usefulness, while role-based access control and OIDC integration make it suitable for shared infrastructure.

Its biggest consideration is security. The standard Docker socket integration provides substantial control over the host, so administrators should carefully configure access and consider the available security alternatives before exposing the dashboard beyond a trusted network.

Overall, Arcane is an excellent choice for developers, homelab enthusiasts, and system administrators looking for a centralized interface to manage Docker and Podman infrastructure.

Sources


Arcane v3.1.1 - Modern Docker Management
Free
Software Informations:
Developer:

Operating System:
macOS / Linux
Date Added:
2026-11-20T02:07:16.435Z

FoneTool Unlocker is a Windows desktop application developed by AOMEI under the FoneTool brand.

The software focuses primarily on unlocking iPhones and iPads by removing passcodes, Apple ID locks, Screen Time restrictions, and MDM profiles in supported scenarios.

Some versions and marketing materials also reference Android related unlocking features, though Apple device support is the platform’s main focus.

FoneTool Unlocker is a mobile device unlocking utility designed to help users bypass screen locks, remove Apple ID restrictions, and regain access to locked smartphones and tablets. The software targets everyday users who may be locked out of their devices due to forgotten passwords or disabled screens, offering a simplified desktop based recovery workflow.

While the tool can be useful in legitimate recovery situations, users should understand the legal, security, and device compatibility limitations before relying on it.

Download FoneTool Unlocker - Software Mirrors

Download Freeware

Download Setup Edition

Key Features of FoneTool Unlocker

  • iPhone Screen Unlocking
    FoneTool Unlocker can remove screen passcodes from supported iPhone and iPad models when users forget passwords or devices become disabled.

  • Apple ID Removal
    The software includes Apple ID removal functions for supported configurations, though availability depends heavily on device status and iOS version.

  • Screen Time Passcode Removal
    Users can bypass or remove forgotten Screen Time restrictions without manually resetting settings.

  • MDM Bypass Support
    Some editions support bypassing Mobile Device Management restrictions on certain devices.

  • Simple Guided Workflow
    The application is designed for non technical users, with step by step instructions for recovery and unlocking operations.

User Experience

FoneTool Unlocker focuses on simplicity rather than technical depth. The interface is modern, minimal, and easy to navigate compared to many older mobile recovery tools.

Most operations involve connecting the device, selecting the unlock mode, and following guided prompts.

However, users should understand that unlocking success rates vary significantly depending on device generation, iOS version, Find My status, activation locks, and Apple security protections.

Performance and Reliability

The software generally performs well for supported recovery scenarios, especially basic screen lock removal.

More advanced functions such as Apple ID removal and MDM bypass can be inconsistent because Apple frequently changes security systems and activation protections.

Users should also expect device wipes in many unlocking scenarios. Removing passcodes often requires restoring the device, which erases stored data unless backups exist.

Security and Ethical Considerations

This category of software always carries important ethical and legal considerations.

Tools like FoneTool Unlocker are intended for recovering access to devices users legitimately own. Attempting to bypass protections on stolen, unauthorized, or managed corporate devices may violate laws, organizational policies, or platform security rules.

Users should also be cautious about unrealistic marketing claims common within the phone unlocking industry. No tool can universally bypass all modern Apple security systems under every condition.

Pros

  • Simple and beginner friendly interface

  • Supports multiple iPhone unlocking scenarios

  • Guided recovery workflow

  • Useful for legitimate forgotten passcode recovery

  • Modern Windows application design

Cons

  • Success rates vary heavily by device and iOS version

  • Many operations erase device data

  • Advanced unlocking claims may not work universally

  • Limited usefulness against modern activation protections

  • Ethical and legal concerns if misused

FoneTool Unlocker is best suited for users attempting to regain access to their own locked devices after forgotten passcodes or management restrictions.

It may also help IT technicians handling supported recovery scenarios for authorized devices.

Users expecting guaranteed bypasses for all Apple security protections should keep expectations realistic.

FoneTool Unlocker offers a polished and accessible approach to mobile device recovery and unlocking. For legitimate passcode recovery situations, it can be convenient and easy to use. However, Apple’s evolving security protections, device compatibility limitations, and the nature of the unlocking category itself mean results can vary substantially depending on the specific scenario.

FoneTool Unlocker 3.2.0 Professional - Discount 30% OFF
$41.96$59.95
Software Informations:
Developer:

Operating System:
Windows
Date Added:
2026-11-20T02:07:16.245Z

The Gemini app for Windows brings Google's AI assistant directly to the Windows desktop. It provides quick access to Gemini through the Alt + Space keyboard shortcut, alongside a dedicated workspace for AI-assisted tasks, Google app integrations, and image and video generation. It is available globally for Windows 10 and Windows 11.

For Windows users who regularly use Gemini, the desktop application is a more convenient alternative to keeping Gemini open in a browser tab.

Features

The Gemini app for Windows includes:

  • Native Windows desktop application

  • Alt + Space keyboard shortcut for quick access

  • Dedicated Gemini workspace

  • Access to Gemini's AI features from the desktop

  • Integration with Google apps such as Gmail and Google Drive

  • Multi-step task assistance through Gemini Spark

  • AI image generation

  • AI video generation

  • Document drafting and summarization

  • File organization assistance

  • Lightweight background operation

  • Support for Windows 10 and Windows 11

Review

The main advantage of the Gemini app for Windows is convenience. Instead of opening a browser and navigating to Gemini, users can press Alt + Space and bring the assistant over their current workflow. This makes it more practical for quick questions, writing, research, and other everyday tasks.

The dedicated workspace is more useful for longer sessions. Google has also integrated access to its broader ecosystem, allowing Gemini to work with information from services such as Gmail and Google Drive. Gemini Spark can handle more complex, multi-step tasks, although availability and capabilities can depend on the user's account and region.

Creative features are another strong point. The Windows application provides access to Google's image and video generation capabilities, allowing users to create content without switching to another application.

The desktop shortcut is arguably the most useful feature for everyday use. It turns Gemini into something closer to a desktop assistant rather than simply another website.

There are still reasons to use the web version. The Windows app is new, and Google says additional native desktop capabilities will continue to roll out. Some of the more advanced agent features are also subject to availability, subscription level, and regional restrictions.

Overall, the Gemini app for Windows is a worthwhile upgrade for regular Gemini users. Its strongest benefit is not a fundamentally different AI experience, but how much easier it makes Gemini to access while working on Windows.

Performance and Compatibility

Google describes the Windows application as lightweight and designed to run in the background without significantly slowing down the computer. The application is officially available for Windows 10 and Windows 11.

Because Gemini is primarily a cloud-based AI service, the application's performance depends heavily on the internet connection and Google's servers. More demanding operations such as image and video generation are processed through Google's AI services rather than relying entirely on local hardware.

The app is therefore suitable for a wide range of Windows PCs, provided they can run the supported version of Windows and maintain a reliable internet connection.

System Requirements

Google officially lists support for:

  • Windows 10

  • Windows 11

  • Internet connection

  • Google account for Gemini services

The Gemini app does not require a dedicated AI accelerator or high-end GPU for its standard AI functionality because processing is primarily performed through Google's cloud infrastructure.

Pros and Cons

Pros

  • Native Windows desktop experience

  • Quick Alt + Space shortcut

  • Easy access while working in other applications

  • Google Gmail and Drive integration

  • Dedicated workspace for longer tasks

  • Image and video generation

  • Gemini Spark support

  • Available globally

  • Supports Windows 10 and 11

  • Lightweight desktop application

Cons

  • Requires an internet connection for its cloud-based AI features

  • Some advanced features depend on subscription and region

  • New desktop application with more native features still being developed

  • The web version may still be preferable for some workflows

How to Install

Download the Gemini app for Windows from Google's official Gemini desktop download page and install it on a supported Windows PC.

After installation, sign in with your Google account. Once configured, you can launch Gemini normally or use the Alt + Space keyboard shortcut to quickly open the assistant while working in another application.

Frequently Asked Questions

Is there an official Gemini app for Windows?

Yes. Google officially launched the Gemini app for Windows in September 2026.

Does the Gemini Windows app work on Windows 10?

Yes. Google states that the Gemini app for Windows supports both Windows 10 and Windows 11.

What is the shortcut for Gemini on Windows?

The default shortcut is Alt + Space, which opens Gemini over the current desktop workflow.

Can Gemini for Windows access Google Drive?

Yes. Google says the desktop app can work with Google apps including Gmail and Google Drive.

Can Gemini for Windows generate images and videos?

Yes. The Windows application provides access to Gemini's image and video creation capabilities.

Is Gemini for Windows free?

The Gemini app itself is available to Windows users, but access to particular Gemini models and advanced features can depend on Google's available plans and account eligibility.

Does Gemini for Windows work offline?

The main Gemini AI functionality is cloud-based, so an internet connection is required for normal use.

Is Gemini for Windows better than using Gemini in a browser?

For regular Windows users, the main advantage is convenience. The Alt + Space shortcut and desktop workspace make Gemini much easier to access without keeping a browser tab open. The underlying AI experience still depends on the Gemini services and features available to your account.

Gemini app for Windows - Update 2026.11.19
Free
Software Informations:
Developer:

Operating System:
Windows
Date Added:
2026-11-20T01:07:59.827Z

Resend CLI is a developer focused command line interface provided by Resend. It allows developers to interact with the Resend email API directly from the terminal.

The tool is designed to:

  • Send test emails

  • Manage domains and API keys

  • Debug email delivery issues

  • Integrate email workflows into development pipelines

It is especially useful for developers building applications that rely on transactional emails.

Download Resend CLI v2.29.0 - Software Mirrors

Download resend-windows-x64.zip

Download resend-linux-x64.tar.gz

Download resend-linux-arm64.tar.gz

Download resend-darwin-x64.tar.gz

Download resend-darwin-arm64.tar.gz

Download checksums.txt

Resend CLI v2.29.0 Release Notes:

Install

cURL
curl -fsSL https://resend.com/install.sh | bash
Node.js
npm install -g resend-cli
Homebrew (macOS / Linux)
brew install resend/cli/resend
PowerShell (Windows)
irm https://resend.com/install.ps1 | iex

What's Changed

  • feat(domains): add forge enable and the forge scope on verify by @felipefreitag in #454
Full Changelog: v2.28.2...v2.29.0

Key Features of Resend CLI

Command Line Email Sending

Resend CLI allows developers to send emails directly from the terminal.

Users can:

  • Send test messages

  • Validate email templates

  • Trigger transactional email flows

This eliminates the need for manual testing through application interfaces.


Domain and API Management

The CLI provides tools to manage email infrastructure:

  • Add and verify domains

  • Manage API keys

  • Configure sending settings

This helps developers maintain control over their email environment without leaving the terminal.


Email Testing and Debugging

Resend CLI simplifies debugging by allowing developers to test email delivery quickly.

Features include:

  • Checking delivery status

  • Identifying errors in email configuration

  • Validating sender domains

This reduces time spent troubleshooting email issues.


Integration with Development Workflows

Because it is CLI based, Resend CLI integrates easily into:

  • CI and CD pipelines

  • Deployment scripts

  • Automation workflows

This makes it suitable for modern DevOps environments.


Template Support

Developers can test and manage email templates directly.

This allows:

  • Previewing email content

  • Testing dynamic variables

  • Ensuring formatting consistency


Lightweight and Fast

The CLI tool is lightweight and designed for quick execution.

Benefits include:

  • Minimal system resource usage

  • Fast command execution

  • Easy installation and setup


Performance and Usability

Resend CLI is optimized for developers who prefer terminal based tools.

Performance highlights:

  • Fast response times for API calls

  • Reliable command execution

  • Smooth integration with scripts

Usability considerations:

  • Requires familiarity with command line interfaces

  • Setup may involve API configuration

  • Not intended for non technical users


Pros and Cons

Advantages

  • Simple and efficient CLI workflow

  • Fast email testing and debugging

  • Integrates with CI and CD pipelines

  • Lightweight and easy to install

  • Developer friendly design


Limitations

  • Requires Resend platform usage

  • Not suitable for non technical users

  • Limited functionality outside email workflows

  • Dependent on API connectivity


Who Should Use Resend CLI

Resend CLI is ideal for:

  • Developers building email enabled applications

  • DevOps engineers automating workflows

  • Teams testing transactional email systems

  • Users working in terminal based environments

It is particularly useful for projects that rely heavily on email APIs.


Final Verdict

Resend CLI is a powerful and efficient tool for managing email workflows directly from the command line. With features for sending, testing, and debugging emails, it simplifies development processes and improves productivity.

For developers using the Resend platform, Resend CLI is a practical addition that enhances control and streamlines email integration.

Email remains a critical part of modern applications, and developers often need reliable tools to test, send, and manage transactional emails efficiently. Resend CLI is a command line tool designed to simplify email workflows for developers using the Resend platform.

Resend CLI v2.29.0
Free
Software Informations:
Developer:

Operating System:
Windows / macOS / Linux
Date Added:
2026-11-20T01:07:59.271Z

Kandev is an open source AI-powered development environment designed to orchestrate multiple coding agents in parallel. Rather than acting as a single AI coding assistant, Kandev provides a Kanban-style workspace where developers can assign tasks to different AI agents, review their work, manage Git worktrees, and create pull requests from a unified interface. It supports multiple AI providers, is self-hostable, and runs entirely without telemetry, making it an excellent choice for teams and developers who want greater control over AI-assisted software development.

As AI coding assistants become more capable, developers often want to run several agents simultaneously. Managing multiple terminal windows quickly becomes difficult, especially when reviewing changes, tracking conversations, and merging code.

Kandev solves this problem by providing a visual development environment with Kanban and pipeline views. Each task can run in its own Git worktree, allowing several AI agents to work independently without interfering with one another. Developers can then review generated code, compare changes, and approve pull requests from a single workspace.

Key Features Kandev

Multi-Agent Orchestration

Kandev can launch multiple AI coding agents simultaneously, allowing different tasks to be completed in parallel. This significantly improves productivity when working on larger projects.

Kanban Workflow

The built-in Kanban board helps organize development tasks, track progress, and visualize AI-assisted workflows in a familiar project management interface.

Integrated Code Review

Instead of switching between terminal windows, Kandev provides a unified workspace with:

  • File editor

  • Git diff viewer

  • File tree

  • Terminal

  • Browser preview

  • Agent conversations

This makes reviewing AI-generated code much more efficient.

Multiple AI Provider Support

Kandev supports numerous AI coding agents through the Agent Client Protocol (ACP), including:

  • Claude Code

  • OpenAI Codex

  • GitHub Copilot

  • Gemini CLI

  • Amp

  • Auggie

  • OpenCode

Developers are free to choose the provider that best fits their workflow.

Flexible Execution

Agents can run in several environments:

  • Local processes

  • Docker containers

  • Remote SSH servers

  • Cloud executors

This flexibility allows teams to scale workloads without relying solely on local hardware.

Git Worktree Management

Each task runs in its own Git worktree, reducing merge conflicts and allowing multiple features or bug fixes to be developed simultaneously.

Self-Hosted and Privacy Focused

Kandev is fully self-hostable and collects no telemetry. Organizations that handle sensitive source code can keep their development environment entirely within their own infrastructure.

Cross-Platform Support

The application runs on Windows, macOS, and Linux. It can be installed using Homebrew, NPX, npm, or by building directly from source.

Download Kandev v0.102.0 - Software Mirrors

Kandev v0.102.0 for Windows

kandev-windows-x64.zip | 81.05 MB

kandev-windows-x64.tar.gz | 81.06 MB

kandev-windows-x64-full.zip | 142.48 MB

kandev-windows-x64-full.tar.gz | 142.5 MB

kandev-desktop-windows-x64-Kandev_0.102.0_x64-setup.nsis.zip | 58.72 MB

kandev-desktop-windows-x64-Kandev_0.102.0_x64-setup.exe | 58.72 MB

Kandev v0.102.0 for macOS

kandev-macos-x64.tar.gz | 80.14 MB

kandev-macos-x64-full.tar.gz | 141.42 MB

kandev-macos-arm64.tar.gz | 75.78 MB

kandev-macos-arm64-full.tar.gz | 137.05 MB

kandev-desktop-macos-x64-Kandev_0.102.0_x64.dmg | 85.9 MB

kandev-desktop-macos-x64-Kandev.app.tar.gz | 87.44 MB

kandev-desktop-macos-arm64-Kandev_0.102.0_aarch64.dmg | 81.55 MB

kandev-desktop-macos-arm64-Kandev.app.tar.gz | 83.37 MB

agentctl-darwin-arm64.gz | 15.54 MB

agentctl-darwin-amd64.gz | 16.34 MB

Kandev v0.102.0 for Linux

kandev-linux-x64.tar.gz | 80.21 MB

kandev-linux-x64-full.tar.gz | 141.64 MB

kandev-linux-arm64.tar.gz | 74.01 MB

kandev-linux-arm64-full.tar.gz | 135.44 MB

kandev-desktop-linux-x64-Kandev_0.102.0_amd64.deb | 88.58 MB

kandev-desktop-linux-x64-Kandev_0.102.0_amd64.AppImage.tar.gz | 152.45 MB

kandev-desktop-linux-x64-Kandev_0.102.0_amd64.AppImage | 153.87 MB

kandev-desktop-linux-x64-Kandev-0.102.0-1.x86_64.rpm | 88.59 MB

kandev-desktop-linux-arm64-Kandev_0.102.0_arm64.deb | 83.07 MB

kandev-desktop-linux-arm64-Kandev_0.102.0_aarch64.AppImage.tar.gz | 145.29 MB

kandev-desktop-linux-arm64-Kandev_0.102.0_aarch64.AppImage | 146.65 MB

kandev-desktop-linux-arm64-Kandev-0.102.0-1.aarch64.rpm | 83.07 MB

agentctl-linux-arm64.gz | 14.51 MB

agentctl-linux-amd64.gz | 15.67 MB

Others Download related to Kandev v0.102.0

runtime-size-report.md | 1.29 kB

kandev-browser-demo.tar.gz | 16.6 MB

Kandev v0.102.0 Source Code

Kandev v0.102.0 Source code (zip)

Kandev v0.102.0 Source code (tar.gz)

Kandev v0.102.0 Release Notes:

[!WARNING]
macOS, Windows desktop installers in this release are unsigned development builds.
They may require manual OS security bypasses and are not trusted downloads.
>
If macOS blocks Kandev after you verify the checksum, run:
>
bash
xattr -d com.apple.quarantine /Applications/Kandev.app
</blockquote>

0.102.0 - 2026-11-19

Features

  • recover managed Git credentials after idle expiry (#5374)
  • simplify agent runtime update dialog (#5371)
  • render rich task references in agent messages (#5361)
  • open Markdown files in preview by default (#5366)
  • support plugin panels in reusable profiles (#5354) by @Fclem
  • combine GitHub repository scope selections (#5284) (#5365)
  • make composer storage warnings dismissible (#5359)
  • add lifecycle safeguards and PR screenshot evidence (#5348)
  • scope built-in MCP routes to helper instances (#5336)
  • consolidate remaining contributor changes (#5321)
  • add optional provider-scoped formatters (#5141) by @yontani
  • searchable repository and organization pickers for watches and scope (#5283) by @point-source
  • hold dependents behind failed blockers and escalate once (#5277) by @point-source
  • consolidate task completion admission and effects (#5281)
  • add runtime update manager and reviewed bulk updates (#5248)
  • toggle built-in packages directly from lists (#5302)
  • track agent-created worktrees in task panels (#5255)
  • allow agent edits to custom prompts (#5265)

Bug Fixes

  • recover prose after glued Mermaid fences (#5362) (#5368)
  • align loading and recovery feedback (#5363)
  • capture turn changes in shared workspaces (#5358)
  • resume tasks with nested adopted worktrees (#5357) by @JnManso
  • make out-of-scope repositories actionable without leaking scope (#5352) by @jelloeater-agent
  • dock selection comment actions across mobile viewports (#5270) (#5286)
  • tighten editor authorization and argument handling (#5355)
  • improve Kandev workflow provisioning (#5328) (#5345)
  • repair question image repository scope (#5338)
  • recover automatic bases after missing refs (#5335) (#5339)
  • preserve workflow session targets for watcher starts (#5333) (#5343)
  • preserve fork PR discovery and validate retry deadlines (#5344)
  • recover broker-backed SSH sessions after controller loss (#5287) (#5346)
  • compose current workflow step on ordinary starts (#5337) (#5340)
  • retain quick chats until explicit deletion (#5342)
  • bind the dynamic successor turn and surface deferred completions (#5332) by @dreampiler
  • treat an unreadable fork parent as no parent PR (#5326) by @malconvsilva
  • show latest run outcome on automation rows (#5323) by @Fclem
  • keep touch selection comment actions clear of the native menu (#5285) by @point-source
  • archive despite workspace inspection failures (#5325)
  • preserve incremental conversation updates (#4913)
  • settle unsent prompts without blocking recovery (#5322)
  • safely reclaim linked SSH task directories (#5295) (#5319)
  • reconcile stale native recovery history (#5320)
  • preserve live claims during stale recovery (#5317)
  • recover workflow moves from unavailable executors (#5318)
  • use long-running client for repository materialization (#5301) (#5315)
  • classify workflow step mutation errors (#5306) (#5316)
  • recover native sessions safely after restart (#5312)
  • explain uncaptured automation passthrough output (#5291) (#5297)
  • import plugin mcp.json endpoints past author URLs (#5263) by @irab
  • preserve ACP authentication recovery (#5293) (#5298)
  • recover interrupted sessions automatically after restart (#5296)
  • pass Discord secret to release announcement workflow (#5290)
  • preserve quarantine triggers during recovery block migration (#5289)
  • preserve quick terminal across renders (#5272) (#5282)
  • repair repeated native resume recovery (#5256) (#5276)
  • restore PR conflict corner badge priority (#5279)
  • retain session recovery guidance across restarts (#5271)
  • prevent GitHub CLI D-Bus autolaunch (#5262)
  • move tasks to the final workflow step when a user marks them done (#4642) by @point-source
  • require successful children for workflow triggers (#5258) (#5268)

Refactoring

  • remove the built-in Azure DevOps integration in favor of its plugin (#5266) by @JnManso

Documentation

  • replace a personal wiki handle and local path in two ADRs and a spec (#5217) by @nova28
  • keep planning solutions simple (#5311)

Performance and User Experience

Kandev offers a modern interface that combines project management with AI-assisted development. The Kanban workflow feels natural for teams already using agile methodologies, while the integrated review tools reduce context switching between editors, terminals, and Git clients.

The application performs well even when managing multiple concurrent AI sessions, thanks to its orchestrator architecture and support for isolated execution environments. Since it is still a relatively young project, some features continue to evolve rapidly, but active development and frequent updates indicate strong momentum.

Pros

  • Free and open source.

  • Supports multiple AI coding agents.

  • Parallel task execution.

  • Built-in Kanban workflow.

  • Excellent integrated code review tools.

  • Self-hostable with no telemetry.

  • Flexible execution using local, Docker, SSH, or cloud environments.

  • Active development.

Cons

  • Still a relatively new project.

  • Best suited for experienced developers.

  • Requires compatible AI agent tools and API access.

  • Advanced workflows may require some initial configuration.

Who Should Use Kandev?

Kandev is ideal for software developers, engineering teams, AI-assisted coding enthusiasts, and DevOps professionals who frequently work with multiple AI coding agents.

It is especially valuable for teams that want to coordinate parallel AI workflows, maintain human review before merging code, and avoid vendor lock-in by supporting multiple AI providers.

Final Verdict

Kandev introduces a fresh approach to AI-assisted software development by treating AI agents as collaborative team members rather than standalone chatbots. Its combination of multi-agent orchestration, Kanban project management, integrated code review, and self-hosted architecture makes it one of the most promising open source AI development environments currently available.

Although the project is still evolving, its rapid development pace, privacy-focused design, and flexible architecture make it an excellent choice for developers looking to scale their AI-assisted workflows.

Kandev v0.102.0
Free
Software Informations:
Developer:

Operating System:
Windows / macOS / Linux
Date Added:
2026-11-20T00:07:24.192Z