Personal Blog

Encoding videos to AV1

Žan Šadl Ferš — Thu, 01 Oct 2026 00:00:00 +0200

Let's just say i was trying to learn how to better use ffmpeg, and started asking myself "What are the things i needed when working with video content?".

And this is one of the things that came to mind.

I had a bunch of videos, that used the H.264 format, taking alot of disk space. Was looking around for alternative formats, to save space. The best options at that time were VP9 and AV1. Both compress really well, but AV1 is more aggressive in compressing the video stream, and combined with OPUS audio, this resulted in better file size reductions while ensuring minimal quality loss.

Now, regarding container formats to use, i have found so far two options. And these are WebM and MKV. Choose MKV due to it being one of the best multimedia container formats out there, but any of these two should work fine.

Using ffmpeg

The most used option to encode a video AFAIK.

Here is a simple Linux script i made (using the installed ffmpeg package on Linux Mint) that converts whatever video file into a separate .mkv AV1 encoded video file, that is rescaled to 720p with solid quality parameters.

#!/usr/bin/env bash

#################################################
# Encode a video file into the AV1 video format #
# using OPUS audio within a .webm container.    #
#################################################
ffmpeg \
-i "${1}" \
-codec:v libsvtav1 -vf scale=-1:720 -crf 35 -preset 6 \
-codec:a libopus -b:a 192k \
"${1//.*/.mkv}"

The 1. argument is the input filepath.

The output filepath is the input one, with the suffix changed to .mkv .

How i managed to host this blog for free

Žan Šadl Ferš — Thu, 01 Oct 2026 00:00:00 +0200

Before i started to write this blog for real, my biggest problem was "How am i supposed to host this without spending money i barely have?". Hosting itself was ironically not a problem, with GitHub Pages and other free options. But...there was the issue of getting a domain, and these (from what i have seen so far) ALL cost money, monthly!

And i also wanted to avoid using Wordpress, having ads to finance the hosting+domain, and the blog must be GDPR compliant.

I am not a cheapskate, but due to the problems in the job markets at the moment in Slovenia and Europe in general, everything is gettting more expensive and the need to conserve money becomes very important. Selfhosting was also a option, but i am again stuck with the domain problem, since finding someone with a dynamic IP (even a static IP) address is not exactly great.

And i happen to not be the only one trying this out.

How the blog is build and hosted

It gets build using the Pelican static site generator from a collection of Markdown articles i write.
The Pelican output (static webpages) is then deployed/pushed in a Git codeberg repository, when ready.
The actual hosting is finally done using statichost, which fetches the webpages from the codeberg repository and deployes that as a static webpage, with a sane URL.

It's not much, and keep in mind that i use this blog non-commercially. Anyone with abit of Git and Pelican knowhow can make this work.

My thoughts to this hosting approach

To get a reliable free blog hosting option, with GDPR compliance...this, i think, is as good as it gets without things getting more complicated or making to many compromises.

Sure, GitHub Pages and similar can do the same thing, but this is simpler (atleast for me).

In the end, if your looking for a blog to host, this is one of several options to choose from.

How to setup Diffusers for Stable Diffusion XL using a Nvidia Pascal GPU in Linux (Ubuntu or Debian based)

Žan Šadl Ferš — Thu, 01 Oct 2026 00:00:00 +0200

You need to first ensure that all the necessary drivers (CUDA most important) for the Nvidia GPU are installed. This post will NOT cover how to do that.

What i am working with here is a Nvidia GTX 1070, just so you know.

Preparing the project directory and virtual environment

Create a new directory/folder (whichever terminology your familiar with) and cd to it from a terminal instance.

Now pay attention here.

Diffusers uses PyTorch as its backend. PyTorch has several wheel repositories for different CUDA versions, and you need to choose for Pascal GPUs the one compatible with CUDA 12.1 or 12.4.

To get the right working libraries, we need to fetch them from the repository 'https://download.pytorch.org/whl/cu124' using the --index-url pip CLI parameter/argument.

Now, to the Diffusers Framework.

Once the PyTorch things is done, the only thing to watch out for is ensuring transformers is fixed at version 5.5.0 . Why is that? My hunch (and days of trying to figure out why my setup broke when i updated my libraries in my virtual environment), parts of the transformers API was changed in later version, and diffusers didn't take that into account in their newer versions. From my findings, version 5.5.0 was the last working one. Since we want this to just work, make sure that you only get THAT version until diffusers decides to fix this.

Now, lets get to what to run inside our project directory.

python3 -m venv ./venv/
./venv/bin/pip install torch torchvision --index-url 'https://download.pytorch.org/whl/cu124'
./venv/bin/pip install diffusers transformers==5.5.0 accelerate peft

This should be all that is needed to get a working virtual environment setup.

Using Diffusers for running Stable Diffusion XL models

This is now the part in which we need to interact with the Diffusers API. In this case, a regular Python script will do the job, and so, i build one for my needs.

#!./venv/bin/python3
import argparse
from pathlib import Path

import torch
from diffusers import (
    DPMSolverMultistepScheduler,
    StableDiffusionXLPipeline,
)


# Constants.
# ==========
IMAGES_BATCH_COUNT = 2
TORCH_DTYPE = torch.bfloat16


# Prepare and parse the terminal arguments.
# =========================================
args_parser = argparse.ArgumentParser(
    description="Custom program for text-to-image using Stable Diffusion XL models."
)
args_parser.add_argument(
    "--model",
    type=str,
    required=True,
    help="Huggingface repository path to the SDXL model weights.",
)
args_parser.add_argument(
    "--prompt-path",
    type=Path,
    default=Path("./prompt.txt"),
    help="Filepath to the prompt on what to generate.",
)
args_parser.add_argument(
    "--negative-prompt-path",
    type=Path,
    default=None,
    help="Filepath to the prompt on what NOT to generate. Ignored if not set.",
)
args_parser.add_argument(
    "--sampling-steps",
    type=int,
    default=26,
    help="How many steps are performed in the denoising procedure. More usually result in better image quality.",
)
args_parser.add_argument(
    "--guidance-scale",
    type=float,
    default=6.5,
    help="How close it should follow the prompt. Lower values result in more freedom, while higher ones result in more consistency.",
)
args_parser.add_argument(
    "--images-count",
    type=int,
    default=IMAGES_BATCH_COUNT,
    help="How many images should be generated per prompt.",
)
args_parser.add_argument(
    "--seed",
    type=int,
    default=None,
    help="The seed used to set the state of the PRNG. If not set, chooses a random one.",
)
args_parser.add_argument(
    "--output-dirpath",
    type=Path,
    default=Path("./txt2img_batch"),
    help="Where to store the generated images.",
)


parsed_args = args_parser.parse_args()


# Prepare the text-to-image pipeline to generate images.
# ======================================================
prompt = parsed_args.prompt_path.read_text()
negative_prompt = None if parsed_args.negative_prompt_path == None else parsed_args.negative_prompt_path.read_text()

pipeline = StableDiffusionXLPipeline.from_single_file(
    parsed_args.model,
    custom_pipeline="lpw_stable_diffusion_xl",
    torch_dtype=TORCH_DTYPE,
    variant="bfp16",
    safety_checker=None,
)
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
    pipeline.scheduler.config,
    use_karras_sigmas=True,
    algorithm_type="dpmsolver++",
)
pipeline.enable_model_cpu_offload()
pipeline.enable_attention_slicing(slice_size="auto")
pipeline.vae.enable_slicing()

# Generate and save the images.
# =============================
batch_count, leftover_count = divmod(parsed_args.images_count, IMAGES_BATCH_COUNT)
images_batch_sequence = []

if batch_count > 0:
    images_batch_sequence += [IMAGES_BATCH_COUNT] * batch_count
if leftover_count > 0:
    images_batch_sequence += [leftover_count]

generator = None if parsed_args.seed == None else torch.manual_seed(parsed_args.seed)

parsed_args.output_dirpath.mkdir(
    parents=True,
    exist_ok=True,
)
for num_images_per_prompt in images_batch_sequence:
    inference_result = pipeline(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=parsed_args.sampling_steps,
        guidance_scale=parsed_args.guidance_scale,
        num_images_per_prompt=num_images_per_prompt,
        generator=generator,
    )

    file_counter = 0
    saved_image_paths = []
    for generated_image in inference_result.images:
        output_filepath = parsed_args.output_dirpath.joinpath(f"image{file_counter}.png")
        while output_filepath.exists():
            file_counter += 1
            output_filepath = parsed_args.output_dirpath.joinpath(f"image{file_counter}.png")

        generated_image.save(output_filepath)
        saved_image_paths.append(output_filepath.name)

    print(f"Saved the generated {num_images_per_prompt} image/s {saved_image_paths} into the directory '{parsed_args.output_dirpath}'.")

This is what i use to generate AI images with Stable Diffusion XL models. It has a solid CLI interface, and the script can be adapted for ones individual needs if something is insufficient.

One important thing to note, due to the Nvidia GTX 1070 being limited to 8 GB of VRAM, and most Stable Diffusion XL models being around 7 GB, reducing the VRAM usage is a must, and this is done usually with offloading, attention slicing and VAE slicing.

The best case for offloading is using model offloading, but you need to ensure that almost nothing is filling the GPUs VRAM, otherwise the script will likely exit with a out of memory exception when saving the generated images. If that is happening to you way to often, and you have closed all programs, change model offloading to cpu offloading. It will take longer, but crashes should happen rarely. Even better (speed and reliability wise) is using group offloading with CUDA streaming enabled, but this required having more RAM (16 GB is not enough, 24+ GB is recommended).

Regarding attention slicing, it kinda works on the Nvidia GTX 1070, but is very important to enable, since it lowers the VRAM use further, with minimal speed loss. Now, why it is kinda working? Due to FlashAttention (the enabled default on newer PyTorch builds) simply not working with my GPU, and a altenative being urgently needed. My only option (after hours of research and testing) ended up being the enable_attention_slicing method from the base class DiffusionPipeline class, which does (almost) the same thing luckily, so we are not totally fucked yet.

VAE slicing saves memory by splitting large batches of inputs into a single batch of data and separately processes them. This method works best when generating more than one image at a time, which will be the case most of the time, but keep in mind that inference will take longer the more images you generate.

Generating images faster using Ays

Now this is mostly uncharted territory, but i was researching how to speed up the inference of Stable Diffusion XL models on my GPU, and found this gem.

Now, how useful is using the AYS schedule for inference? In my experience, it is so-so.

Yes, its much faster and does generate good enough images. But...the image quality in regards to prompt adherence is worse, and this depends alot on the model your using. If it was fine tuned very well, it will perform mostly fine. If not, the images will most likely look weird.

Also (from my findings), it is best to use the sde-dpmsolver++ scheduler, due to it converging faster and giving good quality results, in 10 steps of inference.

Probably best used for experimenting with new ideas.

Here is the (mostly) same script, but using AYS for the inference.

#!./venv/bin/python3
import argparse
from pathlib import Path

import torch
from diffusers import (
    DPMSolverMultistepScheduler,
    StableDiffusionXLPipeline,
)
from diffusers.schedulers import AysSchedules


# Constants.
# ==========
IMAGES_BATCH_COUNT = 2
TORCH_DTYPE = torch.bfloat16


# Prepare and parse the terminal arguments.
# =========================================
args_parser = argparse.ArgumentParser(
    description="Custom program for text-to-image using normal Stable Diffusion models."
)
args_parser.add_argument(
    "--model",
    type=str,
    required=True,
    help="Huggingface repository path to the SDXL model weights.",
)
args_parser.add_argument(
    "--prompt-path",
    type=Path,
    default=Path("./prompt.txt"),
    help="Filepath to the prompt on what to generate.",
)
args_parser.add_argument(
    "--negative-prompt-path",
    type=Path,
    default=None,
    help="Filepath to the prompt on what NOT to generate. Ignored if not set.",
)
args_parser.add_argument(
    "--guidance-scale",
    type=float,
    default=3.0,
    help="How close it should follow the prompt. Lower values result in more freedom, while higher ones result in more consistency.",
)
args_parser.add_argument(
    "--images-count",
    type=int,
    default=IMAGES_BATCH_COUNT,
    help="How many images should be generated per prompt.",
)
args_parser.add_argument(
    "--seed",
    type=int,
    default=None,
    help="The seed used to set the state of the PRNG. If not set, chooses a random one.",
)
args_parser.add_argument(
    "--output-dirpath",
    type=Path,
    default=Path("./txt2img_batch"),
    help="Where to store the generated images.",
)


parsed_args = args_parser.parse_args()


# Prepare the text-to-image pipeline to generate images.
# ======================================================
prompt = parsed_args.prompt_path.read_text()
negative_prompt = None if parsed_args.negative_prompt_path == None else parsed_args.negative_prompt_path.read_text()

pipeline = StableDiffusionXLPipeline.from_single_file(
    parsed_args.model,
    custom_pipeline="lpw_stable_diffusion_xl",
    torch_dtype=TORCH_DTYPE,
    safety_checker=None,
)
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(
    pipeline.scheduler.config,
    algorithm_type="sde-dpmsolver++",
    solver_order=2,
)
pipeline.enable_model_cpu_offload()
pipeline.enable_attention_slicing(slice_size="auto")
pipeline.vae.enable_slicing()


# Generate and save the images.
# =============================
batch_count, leftover_count = divmod(parsed_args.images_count, IMAGES_BATCH_COUNT)
images_batch_sequence = []

if batch_count > 0:
    images_batch_sequence += [IMAGES_BATCH_COUNT] * batch_count
if leftover_count > 0:
    images_batch_sequence += [leftover_count]

generator = None if parsed_args.seed == None else torch.manual_seed(parsed_args.seed)

parsed_args.output_dirpath.mkdir(
    parents=True,
    exist_ok=True,
)
for num_images_per_prompt in images_batch_sequence:
    inference_result = pipeline(
        prompt=prompt,
        negative_prompt=negative_prompt,
        guidance_scale=parsed_args.guidance_scale,
        num_images_per_prompt=num_images_per_prompt,
        generator=generator,
        timesteps=AysSchedules["StableDiffusionXLTimesteps"],
    )

    file_counter = 0
    for generated_image in inference_result.images:
        output_filepath = parsed_args.output_dirpath.joinpath(f"image{file_counter}.png")
        while output_filepath.exists():
            file_counter += 1
            output_filepath = parsed_args.output_dirpath.joinpath(f"image{file_counter}.png")

        generated_image.save(output_filepath)

    print(f"Saved the generated {num_images_per_prompt} image/s into the directory '{parsed_args.output_dirpath}'.")

Conclusion

It's doable, but will get harder with time, due to lacking software support, and whatever currently works will likely no longer be available in the near future, unless you build the libraries yourself (and even that is sometimes a PITA). How do i know that? Why am i this opinion? cuML and cuDF. Cannot get binary wheels that have Pascal support, and building them locally failed with cryptic error messages (maybe my setup sucks, but it is what it is at the moment). Best i got running is cupy for GPGPU things.

So, if you wanna do it, you still can, but do not expect miracles, and inference on the Nvidia 1000 series is not the best (the GTX 1070 needs around 3:30 minutes for generating 2 images with model offloading enabled, to give you a idea).

Converting images to webp

Žan Šadl Ferš — Wed, 30 Sep 2026 00:00:00 +0200

Let's say i was looking for a way to convert images into a format, that is perfectly suited for webhosting. That means, decent enough quality and low file size.

The classics are .jpg and .png, which are also the most supported. But...there is another good one, that is getting better and better support, while providing smaller file sizes. And that is WebP (there is also AVIF, but its less supported).

From what i know, it was developed by Google and is a good open format.

Now, there comes just one little problem...converting whatever you have into .webp is a pain. So, i have been looking for solutions, and i will share some of them with you.

Using ImageMagick

Probably easiest to use, but requires the ImageMagick software. Can also pre and post process images and supports lots of different image formats. Truly the swiss army knife for image processing over the CLI.

Here is a simple Linux script (using the installed imagemagick package on Linux Mint) that converts whatever image file into a separate .webp image file.

#!/usr/bin/env bash
image_filepath="${1}"

convert "${image_filepath}" -quality 100 "${image_filepath%.*}.webp"

Keep you eye out to the -quality parameter. This one determines if you want lossless or lossy compression.

If your image is complex (lets say, landscape with lots of objects), i recommend using lossy compression and playing with the -quality parameter abit. Servers as a alternative to .jpg.

For logos or simpler images, that cannot hide compression artifacts in complex geometry, just set the -quality parameter at 100, to get lossless compression. Servers as a alternative to .png.

Extract clip from video file

Žan Šadl Ferš — Wed, 30 Sep 2026 00:00:00 +0200

Let's just say i was trying to learn how to better use ffmpeg, and started asking myself "What are the things i needed when working with video content?".

And this is one of the things that came to mind. A simple way to extract a clip from an starting point and length of a video file, and exporting that into another video file with minimal quality loss.

Here are some ways on how i managed to do exactly that.

Using ffmpeg to extract a clip from a specific time point in the video

#!/usr/bin/env bash

INPUT_FILEPATH="${1}"
START_TIME="${2}"
CLIP_DURATION_TIME="${3}"
OUTPUT_FILEPATH="${INPUT_FILEPATH}.clip"

ffmpeg \
-ss ${START_TIME} \
-i ${INPUT_FILEPATH} \
-t ${CLIP_DURATION_TIME} \
-c copy \
${OUTPUT_FILEPATH}

The Bash script takes 3 arguments in total, with the last being optional:

The 1. one is the filepath to the video file.
The 2. one is the starting time, from which to extract the clip. The expected input format is HH:MM:SS, meaning hours, minutes and seconds in two digits.
The 3. one is the duration of the clip. The expected input format is HH:MM:SS, meaning hours, minutes and seconds in two digits.

The clipped video file will have the suffix ".clip" added to the output filename.

Extract video frame/s as image

Žan Šadl Ferš — Tue, 29 Sep 2026 00:00:00 +0200

Let's just say i was trying to learn how to better use ffmpeg, and started asking myself "What are the things i needed when working with video content?".

And this is one of the things that came to mind. A simple way to extract one or several video frames from a video file, and exporting that into a usable image file.

Very useful for making thumbnails from video content, showing specific moments and so on.

Here are some ways on how i managed to do exactly that.

Using ffmpeg to extract a single frame from a specific time in the video

#!/usr/bin/env bash

INPUT_FILEPATH="${1}"
FRAME_TIME="${2}"
OUTPUT_FILEPATH="${3:-${INPUT_FILEPATH//.*/.png}}"

ffmpeg \
-i "${INPUT_FILEPATH}" \
-ss "${FRAME_TIME}" \
-frames:v 1 \
"${OUTPUT_FILEPATH}"

The Bash script takes 3 arguments in total, with the last being optional:

The 1. one is the filepath to the video file.
The 2. one is the starting time, from which to extract the video frame. The expected input format is HH:MM:SS, meaning hours, minutes and seconds in two digits.
The 3. is the output filepath. If not set, will use the input filepath and replace the file extension/suffix with .png.

Using ffmpeg to extract multiple frames from a specific time in the video

#!/usr/bin/env bash

INPUT_FILEPATH="${1}"
FRAME_TIME="${2}"
OUTPUT_FILEPATH="${3:-${INPUT_FILEPATH//.*/.png}}"
FRAME_COUNT="${4:-60}"

ffmpeg \
-i "${INPUT_FILEPATH}" \
-ss "${FRAME_TIME}" \
-frames:v ${FRAME_COUNT} \
"${OUTPUT_FILEPATH}"

The Bash script takes 4 arguments in total, with the third being optional:

The 1. one is the filepath to the video file.
The 2. one is the starting time, from which to extract the video frame. The expected input format is HH:MM:SS, meaning hours, minutes and seconds in two digits.
The 3. is the output filepath. If not set, will use the input filepath and replace the file extension/suffix with .png.
The 4. one is the amount of frames to extract from the starting time onwards. If not set, will extract a total of 60.

The Adjustable Grippier Hitch

Žan Šadl Ferš — Tue, 29 Sep 2026 00:00:00 +0200

A new knot i developed, based on the well known Adjustable Grip Hitch. Did a post on that in the IGKT forum.

The idea came to me when i asked myself "Can the Adjustable Grip Hitch be improved in some way?" while practicing knot tying with a hank of cordage. I switched to playing around with different ways to tie the Adjustable Grip Hitch, until it hit me. "Why not finish with a extra round turn, towards the line?". And...this is how it came to be, as unromantic as it sounds.

Now towards its attributes (as far as i tested it). It's main purpose is having a stable adjustable loop, that doesn't loose its grip when handled in different angles (more then 90 degrees). This is impossible with any other slide and grip hitch, with the closest to achieve that being the Adjustable Grip Hitch.

Was tested on grippy (synthetic and natural) and slippery rope (synthetic), and worked fine on both to my suprise. There was abit of slippage with the slippery rope, but it then gripped and stayed put. In my experience, a first.

Now, this knot has not been tested in situations where someones life is on the balance, so i advice to NOT use it for climbing or similar, until it's been further pressure tested from different sources.

Here is a video on how to tie it, for those interested.

Using GNU parallel to automate git pull of GitHub repositories

Žan Šadl Ferš — Tue, 29 Sep 2026 00:00:00 +0200

I personally have cloned hundreds of git repositories of various FOSS and FLOSS projects (for personal needs), and these, of course, should preferably have the latest changes available.

Doing manual git pull commands in each repository separately is insane, and my first effort to automate it proven to be to slow (one pull per repo at a time).

Started researching ways to speed this up in a sane manner, and found GNU parallel. Fits the usecase nicely, and so, i started to experiment with it, to see, if it is up to the task practically. Proven to offer what i need, the same Bash script was rewritten by using parallel in combination with find.

Damn thing ended up being much faster then expected and the git repositories were updated in minutes instead of nearly more then 15 minutes. This was done on a NVME SSD (works OK on a HDD, but don't expect a near x10 speedup).

For anyone interested in the script, here it is:

#!/usr/bin/env bash

NUMBER_OF_PROCESSES_TO_USE=4

echo 'Seeking the git repos within this directory...'
LOCAL_GIT_REPOS=$(find -type d -name '.git' -exec dirname {} ';')
NUMBER_OF_GIT_REPOS=$(echo "${LOCAL_GIT_REPOS}" | wc --lines)

echo "Starting to pull the latest remote changes for ${NUMBER_OF_GIT_REPOS} git repositories (see 'jobs completed' for the current progress)."

echo "${LOCAL_GIT_REPOS}" | \
parallel -j "${NUMBER_OF_PROCESSES_TO_USE}" --progress \
"git -C {} pull --all --recurse-submodules &> /dev/null"

It basically searches from the current working directory the git repositories, that are stored in it, and stores their filepaths (newline delimited) in a Bash variable. Then, those filepaths get feed to parallel, which executes the git pull command with some additional parameters. Not very complicated, but it took some time to get it to run reliably, since i didn't fully understand parallel yet.

Hope this helps anyone who is working on something similar.

My thoughts on the human mind

Žan Šadl Ferš — Thu, 24 Sep 2026 00:00:00 +0200

The human mind is really fascinating.

My personal thoughts on the mind is:

It is a self-actualizing mini-universe, build upon the persons perception of reality.
The people one meets and interacts with get imperfectly replicated (you could argue, into a ghost) and become part of their mini-universe, being to some degree subconsciously influenced by them.
The mind itself hallucinates the things the person couldn't capture from their observation of reality, and fills those blanks with that (however absurd these may be), to fill the blanks.
The mind doesn't want/cannot to be directly controlled, but can be directed.

Why IoT devices are overrated

Žan Šadl Ferš — Thu, 24 Sep 2026 00:00:00 +0200

IoT (Internet of Things)...

I personally never liked them. You give to much control to the manufacturer, and most of the internet functionality is not that useful (mostly being remote access). And they are also targets for cyberattacks (from what i read, usually used to make them part of botnets).

This doesn't mean that they are useless. Just...the way they are developed and released makes me despise them.

They can be made better by making the Internet centric functionality optional and non-intrusive. And also offering to the end-user guides on how to maintain them (both hardware and software), when they are discontinued. Also, making the devices as privacy-friendly as possible, but that is to much to ask for these days, due to how selling your data is a way to make some money, and these IoT devices are usually quick-to-market products for a quick cash grab.

Been thinking personally on how to design the optimal IoT device, since just complaining gets nothing done. With that in mind, i came to the following things to keep in mind for developing one:

The hardware must be something that is readily available, affordable, easy to replace and service.
The software must be developed with FOSS/FLOSS components, that are fully free and open source. This is not for charity, but to keep it running, even when it gets discontinued. Also shows to people, that your product is trustworthy, by being transparent.
Keep the Internet-centric functions optional, and make them actually provide value to the end-user.
Not requiring a smartphone app for using it (THIS is my biggest gripe). And if an external user interface is needed, please, stop requiring the user to create a account on their device.

My knots "Compact Series"

Žan Šadl Ferš — Thu, 22 Jan 2026 16:20:00 +0100

There are just to many knots to know about, but which do the job while not being overly complicated and easy to tie and untie, the list will usually be some derivative of the most popular nautical and scouting knots.

While these are quite good, i am not satisfied. And new types of knots have been developed, that could prove very useful if put to use (like the Icicle Hitch and Adjustable Grip Hitch).

So i went ahead and studied different types of knots, both old and new, and started making notes on which is for what purpose best, and how good it is compared to equivalent ones.

Important thing that needed to be demonstrated are:

The fewest number of knots that cover 90 % of usecases.
Teaches the basics.
Simple to teach.
Reasonably easy to tie and untie.
Hold stable on most types of rope.
Can be used as the basis to learn more complex knots.

The first point ended up being the hardest. Each knot is on its own good, but to cover a this large amount of usecases was just unrealistic. Ended up iteratively studying different types of knots and playing around with them, assesing their qualities and properties. With each iteration (repeated or not), i got a better understanding of what knot will do the job. Ended up with a list of 7 knots, and went through many iterations, and its these 7 that stuck.

They are:

Round Turn and Two Half Hitches
Clove Hitch
Square Knot
Fishermen's Bend
Adjustable Grip Hitch
Bowline Knot
Trucker's Hitch

They teach nearly all basic forms, lead to their more complex counterparts smoothly, and will work reliably without many hickups.

I am very proud to have managed to get this list created, and hope that it helps people in their pursuits.

The knots described

Round Turn and Two Half Hitches

A basic nautical hitch.

It teaches the round turn and its utility, the Half Hitch and what happens if you tie two Half Hitches one after another. Also, that the two Half Hitches make a stable tieoff.

Clove Hitch

A basic nautical hitch for being tied to a pole.

It teaches that the Half Hitches can have different configurations with abit of creativity.

Square Knot

A basic knot, that is also a tieoff.

Teaches the Half Knot, and what happens if two Half Knots are tied one after another.

Fishermens Knot

Basic bend for making slings or joining ropes of similar diameter.

Teaches the overhand knot, its use as a stopper knot, and what happens if two of such stopper knots are tied in opposing positions.

Adjustable Grip Hitch

Multipurpose adjustable endloop.

Uses the round turn to prepare the initial loop, before being finished off with a well-placed Half Hitch.

Bowline Knot

Fixed endloop.