🔥 Build your own image CDN system your way with lust.
Lust is an auto-optimising image server, designed for high throughput and low latency handling of images, now that is lustful.
Re-encode uploaded images into
webp or even into
gif based formats!
Resize them to your liking automatically with sizing presets, instantly create small, medium and large variants with just a few line in a config file. Now that's the spirit of lust
And much more like caching, on the fly resizing and diffrent processing modes to name a few.
Creating a config file
It's highly advised to take a look at some example config files to get an idea of what a general config file would look like.
Full documentation in markdown form can also be found here, this is also served directly by the server as part of the documentation ui endpoint.
Building from Source
To building from source, just clone this repo via
git clone https://github.com/chillfish8/lust.git and then run
cargo build --release.
Installing via Cargo
You can install lust directly via cargo and the git flag:
cargo install lust --git https://github.com/ChillFish8/lust.git
Lust has a set of pre-built, optimised docker images ready to go. Just run it with
docker run -v "my_configs:/var/lust/" chillfish8/lust:latest --config-file "/var/lust/config.yaml"
Note: Assuming there is a folder called
my_configs with a
config.yaml file in it.
Once you're up and running navigate to
/ui of what ever port your server is running on
to see the full OpenAPI docs.
Lust makes use of a Least Recently Used in-memory cache which can be adjusted for your needs via the
cache_size key in the configuration file.
The larger the number the more images it will cache at once and vice versa.
NOTE: With bigger images this can create much higher RAM usage
Lust's ability to scale is purely down to the backend you use, so it is worth noting that the file system backend is only really designed for testing. For full scale deployment consider using Scylla or a s3 compatible blob store to serve data from.
If your goal is high-end performance, Scylla DB will be the most performant by a large margin, but this will come with a higher operating cost.
Lust supports any of the following formats:
Any uploaded images will be given a unique uuid and be re-encoded into all the other enabled formats in all presets. This is especially useful when you want to serve several variants of the same image with different formats.
You can also adjust this based on the processing mode,
aot/Ahead of time encoding will follow the old
lust behavour by encoding and resizing each image at upload time.
jit/Just in time encoding will only resize and re-encode at request time, storing a base copy
of the file to generate new images. This can save on a considerable amount of CPU time and disk space
depending on your requirements.
Finally, we have the
realtime encoder, this will only store an original copy like the
but instead will never save the resized and encoded image, this does also enable the ability to
do on the fly resizing and is recommended for situations where you're not expecting to serve image
to the public network.
The server can take several sizing presets which can be targeted via the
query parameter when getting an image.
These presets will mean every image at upload time will be resized to
fit the width and height bounds using the configured resizing filter
(defaults to nearest neighbour).
Regardless of presets an
original image is always stored and can be accessed via the
The default preset when served without a
size parameter can be set in the configuration file via
Lust's data storage efficiency is roughly the same as storing on a plain file system outside any system the database backend employs when storing the data.