slimtoolkit

slim: Make Containers Smaller and More Secure

Slim is a Go-based toolkit for inspecting, optimizing and debugging container images without changing your usual image-building workflow. Its dynamic analysis can produce smaller images and security profiles for Docker and other container environments.

MaintainedGoApache-2.0GolangDockerSecurity
View on GitHub Compare
Stars
23.5k
Forks
852
Stars, last 30 days
+96
Last commit
1 month ago
Contributors
71

Our take

Maintaineda few commits in the last 90 days

Health score

45/100

How it is scored
Activity
29
Community
60
Issues
46
Pull requests
46

+96 stars in the last 30 days

Slim is a capable container optimization and analysis toolkit with broad contributor participation, but its release history is much quieter than its recent source activity.

Good fit if

  • You want to analyze or minimize container images while preserving your current image-building workflow.
  • You can exercise the application during analysis and validate the resulting image with your own tests.
  • You need image inspection, generated security profiles or sidecar-based container debugging in one CLI.

Look elsewhere if

  • Your workflow requires a recent published release, since the latest listed release is from 2024 despite commits in the last few weeks.
  • You need dynamic analysis to discover every dependency without supplying probes, tests or explicit includes.
  • You need Dockerfile linting to cover image contents, which the README describes as work in progress.
All health signals
Last commit2026-09-19 (1 month ago)
Commits, last 90 days2
Releases, last 12 months0 (latest 1.40.11, 2024-02-02)
Contributors71 (top contributor: 72% of commits)
Issues closed, last 90 days1
Pull requests merged, last 90 days2
Project age11 years

Checked on 2026-10-24 with the GitHub API.

Project history

Daily GitHub snapshots since Oct 7, 2026. History covers stars and forks; health signals are not tracked historically.

Selected snapshot

Stars

23,534

Forks

850

Change since Nov 17, 2026: +4 stars·0 forks

Overview

Slim, also known as SlimToolkit, is a Go-based toolkit for inspecting, optimizing and debugging container images. It aims to make containers smaller and reduce their attack surface without requiring teams to replace their base images, package managers or Dockerfile workflow. The project describes support across container tools and runtimes in the cloud native ecosystem, and documents use with Docker and Kubernetes debugging.

Its build command runs the target application during analysis, observes its behavior and uses the collected information to create an optimized image and security profiles. This can remove unused files, but results depend on exercising the application thoroughly during analysis. Other commands inspect images, lint Dockerfiles, and help debug minimal containers.

Key Features

  • Analyze image contents and layers with xray, including reports that help reverse-engineer how an image was assembled.
  • Use dynamic application analysis with build to create an optimized image and generate Seccomp and AppArmor profiles.
  • Probe HTTP services or run commands and tests against the temporary analysis container to discover runtime dependencies.
  • Add back required files, directories, binaries or application paths when automatic analysis does not capture them.
  • Debug running containers with a sidecar, including documented support for Docker and Kubernetes targets.
  • Lint Dockerfiles and inspect application composition with lint and appbom.
  • Pull, push and create image indexes with registry commands, and combine images with merge.

Use Cases

  • Application teams can reduce deployment image size and remove unused components while keeping their existing Dockerfile workflow.
  • Security teams can generate Seccomp and AppArmor profiles from observed application behavior rather than authoring them entirely by hand.
  • Developers can inspect large or unfamiliar images to identify their contents and layer changes before optimizing them.
  • Operators can troubleshoot a minimal or production container using a separate debug sidecar instead of adding troubleshooting tools to the application image.

What you need

Detected in the repository

  • Go 1.24.0 or newer (from go.mod)
  • A test suite

License in plain words

Apache-2.0permissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the license, the NOTICE file and a note of your changes
  • Share your changes: no
  • Includes an explicit patent grant from the contributors:

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

Install a binary for your platform, use Homebrew, or run the containerized CLI. For example:

docker pull dslim/slim
docker run -it --rm -v /var/run/docker.sock:/var/run/docker.sock dslim/slim build your-docker-image-name

See the README installation and usage instructions for platform-specific downloads, configuration and command options.

Considerations

Dynamic analysis only captures behavior exercised during the run. Applications with dynamically loaded components may need custom HTTP probes, tests, or explicit --include-path entries, so verify the optimized image against your real workloads before deployment. Containerized use of the CLI needs access to the Docker daemon, commonly through its socket; the README also notes that profile generation requires elevated container capabilities. The project is marked maintained and has recent commits, but has had no release in over a year. It has many contributors and activity is not concentrated in one contributor, though recent issue closures are limited. The README identifies Dockerfile image linting as a work in progress.

Found this useful?

Share it with someone who would like slim.