Sovereign 8s.is mirror of standardgalactic/macrolife
  • Shell 49.7%
  • HTML 49.4%
  • Dockerfile 0.9%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
standardgalactic 074de668b1 Deploying Page
2026-08-23 15:38:46 -03:00
images Deploying Page 2026-08-23 15:38:46 -03:00
.dockerignore Deploying Page 2026-08-23 15:38:46 -03:00
.gitignore Deploying Page 2026-08-23 15:38:46 -03:00
demo.png Deploying Page 2026-08-23 15:38:46 -03:00
Dockerfile Deploying Page 2026-08-23 15:38:46 -03:00
index.html Deploying Page 2026-08-23 15:38:46 -03:00
initialize.sh Deploying Page 2026-08-23 15:38:46 -03:00
README.md Deploying Page 2026-08-23 15:38:46 -03:00
report.txt Deploying Page 2026-08-23 15:38:46 -03:00
workflow.json Deploying Page 2026-08-23 15:38:46 -03:00

Macrolife

Macrolife is a small, reproducible image-processing environment built around a curated image collection and a minimal set of general-purpose image and media tools.

The repository contains the image assets and the complete Docker build pipeline. A prebuilt container is also published on Docker Hub for use without a local build.

Docker

The prebuilt Macrolife image is available on Docker Hub:

https://hub.docker.com/r/mechachleopteryx/macrolife

Pull the latest image:

docker pull mechachleopteryx/macrolife:latest

Run it interactively:

docker run --rm -it mechachleopteryx/macrolife:latest

Inside the container, the Macrolife image collection is available at:

/macrolife/images

The default working directory is:

/macrolife

Included Tools

The container provides a compact collection of general-purpose image and media-processing tools.

ImageMagick provides image conversion, resizing, compositing, filtering, and inspection. libvips provides fast, memory-efficient image processing. FFmpeg provides image-sequence, video, audio, codec, filtering, and format-conversion facilities. Python 3 provides a general scripting environment for constructing higher-level processing pipelines.

The intention is to keep the base environment relatively small rather than preinstalling a large collection of specialized packages.

Images

The repository contains the working Macrolife image collection under:

images/

These images are reduced-resolution versions of the original source material. The reduction keeps the repository practical to clone while preserving a directly usable collection rather than packaging the assets inside an opaque archive.

The full-resolution source images are maintained separately under:

source-images/

source-images/ is intentionally excluded from Git.

The repository versions were produced by reducing both dimensions of the source PNG images by 50%. This results in approximately one quarter of the original pixel count.

For example:

mkdir -p images

for f in source-images/*.png; do
    magick "$f" -resize 50% "images/$(basename "$f")"
done

The resulting collection is approximately 123 MB, compared with roughly 500 MB for the full-resolution source set.

Building Macrolife

Clone the repository and build the container from its root:

docker build -t mechachleopteryx/macrolife:latest .

Run the locally built image:

docker run --rm -it mechachleopteryx/macrolife:latest

The Dockerfile copies the repository's images/ directory into the resulting container, so the built image is self-contained.

Testing the Environment

Once inside the container, the installed tools can be checked with:

magick --version
ffmpeg -version
vips --version
python3 --version

Inspect the bundled image collection with:

ls -lh /macrolife/images

A simple ImageMagick test can be performed without modifying the bundled collection:

mkdir -p /tmp/macrolife-test

f=$(find /macrolife/images -type f -iname '*.png' | head -1)

magick "$f" -resize 25% /tmp/macrolife-test/output.png

identify "$f" /tmp/macrolife-test/output.png

Using Host Files

The bundled collection is useful for experimentation, but Macrolife can also process files from the host by mounting a directory into the container:

docker run --rm -it \
    -v "$PWD:/work" \
    mechachleopteryx/macrolife:latest

The host directory will then be available inside the container at:

/work

This allows Macrolife to operate as a disposable image-processing environment without copying additional files into the container itself.

Publishing

The Docker image is tagged under:

mechachleopteryx/macrolife

A local build can be pushed to Docker Hub with:

docker push mechachleopteryx/macrolife:latest

Versioned releases can be tagged independently:

docker tag mechachleopteryx/macrolife:latest \
    mechachleopteryx/macrolife:v0.1

docker push mechachleopteryx/macrolife:v0.1

This allows latest to follow current development while preserving named versions of the environment.

Repository Structure

macrolife/
├── Dockerfile
├── .dockerignore
├── .gitignore
├── README.md
├── workflow.json
├── images/
└── source-images/     # local full-resolution sources; ignored by Git

The distinction between images/ and source-images/ is intentional. Git contains the practical distribution set, while the larger source collection remains outside repository history.

Likewise, .dockerignore prevents the full-resolution sources from being unnecessarily transferred into the Docker build context.

Image Generation Provenance

The image collection predates the minimal Macrolife processing container. The images were generated with a Stable Diffusion pipeline whose workflow is preserved in:

workflow.json

workflow.json is included in the repository so that the generation pipeline itself remains inspectable rather than being represented only by a prose description.

The generation pipeline used the Stable Diffusion 1.5 checkpoint:

v1-5-pruned-emaonly.ckpt

The checkpoint itself is not included in this repository.

The Stable Diffusion runtime environment used for generation was based on:

https://github.com/AbdBarho/stable-diffusion-webui-docker

That project provides a Docker-based environment for running Stable Diffusion with user-facing interfaces and supporting runtime configuration.

The broad provenance chain is therefore:

workflow.json
        |
        v
v1-5-pruned-emaonly.ckpt
        |
        v
AbdBarho/stable-diffusion-webui-docker
        |
        v
generated full-resolution images
        |
        v
source-images/
        |
        |  ImageMagick: -resize 50%
        v
images/
        |
        v
Macrolife Docker image

The full-resolution generated outputs are retained locally as source-images/ but are excluded from Git because of their substantially larger size. The reduced-resolution images/ collection is the distribution set tracked by the repository and incorporated into the Macrolife container.

Checkpoint Identification

For stronger reproducibility, a local copy of the checkpoint can be identified by its SHA-256 digest rather than relying solely on its filename.

On a system containing the checkpoint, run:

sha256sum v1-5-pruned-emaonly.ckpt

The resulting digest can be recorded alongside the checkpoint name:

Checkpoint: v1-5-pruned-emaonly.ckpt
SHA-256: <hash>

This is useful because filenames are descriptive rather than cryptographic identifiers. Recording the digest establishes precisely which checkpoint file was used without requiring the multi-gigabyte model itself to be stored in this repository.

Reproducibility

Macrolife separates three related but distinct artifacts.

The generation workflow is preserved as workflow.json. The generated image collection is preserved in repository-friendly form under images/. The processing environment is specified by the Dockerfile and distributed as a prebuilt Docker image.

The model checkpoint is treated as an external dependency and identified by name, with provision for recording its cryptographic digest.

This separation means that the repository does not need to contain every byte involved in the original generation process in order to preserve a useful account of how the collection was produced.

Philosophy

Macrolife treats the container as a reproducible processing environment rather than as a manually prepared machine.

The Dockerfile is therefore the authoritative description of the current environment. The container can be discarded and rebuilt from the repository at any time.

The project deliberately begins with a small set of broadly capable tools. Additional dependencies can be introduced when a concrete processing task requires them rather than accumulating packages speculatively.

The result is intended to remain understandable, rebuildable, and useful both as a standalone image-processing environment and as a foundation for later Macrolife experiments.