DEV Community: Jasper

Integrating Svelte 5 with GSAP 3

Jasper — Sun, 09 Mar 2025 02:26:50 +0000

Inspired by this post

GSAP is, in my opinion, the go-to library for creating page animations.

If however you have ever tried to use GSAP with Svelte you will know that it can be a cluttered mess of code and a bit fidgety to use.
I mean just take a look at the code I was using for my website.

<script>
    let heroSection;
    let philosophySection;
    let projectsSection;
    let experienceSection;
    let contactSection;

    onMount(() => {
        gsap.registerPlugin(ScrollTrigger);
        // Hero section animations
        gsap.from(heroSection.querySelector('h1'), {
            y: 30,
            opacity: 0,
            duration: 1,
            delay: 0.5
        });

        gsap.from(heroSection.querySelector('.hero-text'), {
            y: 20,
            opacity: 0,
            duration: 1,
            delay: 0.8
        });

    // and so on...
  });
</script>

Obviously there is a better way to do this, after finding the post I linked above it already made things a lot easier!

// animate.js
import { gsap } from 'gsap';

export function animate(node, { type, ...args }) {
  let method = gsap[type];
  return method(node, args);
}

<!-- +page.svelte -->
<a
  use:animate={{
    type: 'from',
    duration: 1,
    scale: 0.9,
    opacity: 0.5,
    ease: 'expo.inOut',
  }}
>Link</a>

There is still a problem with this though. Since it's in JavaScript, there is no type checking and you can't use the autocomplete in your IDE.

After making a few changes it now fully supports TypeScript and meets all the requirements of a Svelte action so the LSP doesn't complain.

// animate.ts
import { gsap } from 'gsap';

type AnimationType = keyof typeof gsap;

interface AnimationOptions extends GSAPTweenVars {
    type: AnimationType;
}

export function animate(
    node: HTMLElement,
    { type, ...args }: AnimationOptions
): { destroy?: () => void } {
    const method = gsap[type] as
        | ((target: gsap.TweenTarget, vars: GSAPTweenVars) => GSAPTween)
        | undefined;

    if (!method) {
        console.warn(`GSAP method "${type}" does not exist.`);
        return {};
    }

    // Create the animation
    const tween = method(node, args);

    return {
        destroy() {
            // Kill the animation when the element is removed
            tween.kill();
        }
    };
}

But there is still one more issue, the scrollTrigger option doesn't work!
And adding gsap.registerPlugin(ScrollTrigger); to your onMount function doesn't work either. A little extra work is needed to get this working.

// animate.ts
import { gsap } from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';

// Register the ScrollTrigger plugin with GSAP
gsap.registerPlugin(ScrollTrigger);

type AnimationType = keyof typeof gsap;

interface AnimationOptions extends GSAPTweenVars {
    type: AnimationType;
    scrollTrigger?: ScrollTrigger.Vars;
}

export function animate(
    node: HTMLElement,
    { type, scrollTrigger, ...args }: AnimationOptions
): { destroy?: () => void } {
    const method = gsap[type] as
        | ((target: gsap.TweenTarget, vars: GSAPTweenVars) => GSAPTween)
        | undefined;

    if (!method) {
        console.warn(`GSAP method "${type}" does not exist.`);
        return {};
    }

    // Create the animation with ScrollTrigger if provided
    const tween = method(node, {
        ...args,
        scrollTrigger: scrollTrigger
            ? {
                    ...scrollTrigger,
                    trigger: scrollTrigger.trigger || node
                }
            : undefined
    });

    return {
        destroy() {
            // Kill the animation when the element is removed
            tween.kill();

            // If using ScrollTrigger, make sure to kill that instance too
            if (scrollTrigger && tween.scrollTrigger) {
                tween.scrollTrigger.kill();
            }
        }
    };
}

This updated code registers the ScrollTrigger plugin with GSAP and allows you to pass in a scrollTrigger option to the animate function. In doing this it will automatically set the element you have used this action on as the scrollTrigger.trigger element!

Now you can use it like this and have full type checking in your IDE:

<div class="overflow-hidden">
  <h1
    class="font-serif text-7xl font-medium"
    use:animate={{
      type: 'from',
      duration: 1,
      yPercent: 100,
      ease: 'power4.out',
      scrollTrigger: {
        start: 'top 70%',
        end: 'top 20%',
        toggleActions: 'play none none reverse'
      }
    }}
  >
    Other content
  </h1>
</div>

I hope this helps and massive shoutout to Khutso Siema for the original post.

NixOS Full Disk Encryption with USB/SD-Card/Password Unlock

Jasper — Fri, 01 Nov 2024 07:11:50 +0000

Not long ago I had some super secure data on my server and I wanted it to survive just about anything from a network attack to a physical theft.
Now the NixOS documentation is a bit lacking on this topic, but I've found a few resources that helped me to get this working.
Here you go guys, finally a single guide with all the steps.

References:

Note

This guide does expect that you are in the minimal ISO and have connected to your network via Ethernet or wpa_cli.
If you want to know how to setup NixOS from the very beginning, check out my NixOS Homelab Install Guide.

Partitioning

Note

In the following snippets I will refer to the drive we are encrypting as /dev/sda but yours might be /dev/nvme0n1.

If you haven't already, switch to the root user with sudo -i

# Open gdisk on the disk we're installing on
gdisk /dev/sda

# -----------------------
# BEGIN GDISK COMMANDS

# print the partitions on the disk
Command: p

# Delete a partition. Select the partition number when prompted.
# Repeat for all partitions.
Command: d

# Create the EFI boot partition
Command: n
Partition number: 1
First sector: <enter for default>
Last sector: +1G       # make a 1 gigabyte partition
Hex code or GUID: ef00 # this is the EFI System type

# Create the LVM partition
Command: n
Partition number: 2
First sector: <enter for default>
Last sector: <enter for default - rest of disk>
Hex code or GUID: 8e00 # Linux LVM type

# Write changes and quit
Command: w

# END GDISK COMMANDS
# ---------------------

If you want more of an explanation on what these commands are doing please look at the Queensland FP Lab - Installing NixOS post as it is really good!

Formatting and Encryption

$LVM_PARTITION is /dev/nvme0n1p2 or /dev/sda2, this is the second partition we just created.

# You will be asked to enter your passphrase - DO NOT FORGET THIS
cryptsetup luksFormat $LVM_PARTITION

If you want to decrypt the drive on boot without input you can write a decryption key to a USB or SD Card.
As an example if you only ever access this computer via SSH you will want the computer to be able to boot independantly without needing a password input.

Note this method will make the decryption drive unusuable for anything else.

# Create a random key
dd if=/dev/random of=hdd.key bs=4096 count=1
# Append the key to the list of secure keys that can unlock the drive.
cryptsetup luksAddKey $LVM_PARTITION ./hdd.key

# Now write the key to your USB or SD Card, find it from lsblk.
dd if=hdd.key of=/dev/REPLACE-HERE

Continue here.

# SKIP TO HERE IF NOT USING USB UNLOCKING.
# Decrypt the encrypted partition and call it nixos-enc. The decrypted partition
# will get mounted at /dev/mapper/nixos-enc
cryptsetup luksOpen $LVM_PARTITION nixos-enc

# Create the LVM physical volume using nixos-enc
pvcreate /dev/mapper/nixos-enc

# Create a volume group that will contain our root and swap partitions
vgcreate nixos-vg /dev/mapper/nixos-enc

# Create a swap partition that is 16G in size - the amount of RAM on this machine
# Volume is labeled "swap"'
lvcreate -L 16G -n swap nixos-vg

# Create a logical volume for our root filesystem from all remaining free space.
# Volume is labeled "root"
lvcreate -l 100%FREE -n root nixos-vg

# $BOOT_PARTITION is your first partition, so `/dev/nvme0n1p1` or `/dev/sda1`

# Create a FAT32 filesystem on our boot partition
mkfs.vfat -n boot $BOOT_PARTITION

# Create an ext4 filesystem for our root partition
mkfs.ext4 -L nixos /dev/nixos-vg/root

# Tell our swap partition to be a swap
mkswap -L swap /dev/nixos-vg/swap

# Turn the swap on before install
swapon /dev/nixos-vg/swap

Now let's mount the file system.

mount /dev/nixos-vg/root /mnt
mkdir /mnt/boot
# $BOOT_PARTITION is your first partition, so `/dev/nvme0n1p1` or `/dev/sda1`
mount $BOOT_PARTITION /mnt/boot

From here just generate a new configuration and replace the existing boot options with the following.

boot = {
  loader = {
    efi.canTouchEfiVariables = true;
    grub = {
      enable = true;
      efiSupport = true;
      device = "nodev";
    };
  };
  initrd = {
    kernelModules = ["usb_storage"];
    luks.devices.cryptroot = {
      device = "/dev/second-partition-of-your-drive";
      preLVM = true;

      # If using a USB or SD Card for decryption include the following.
      allowDiscards = true;
      keyFileSize = 4096;
      # This is the disk id of your USB or SD Card.
      # Get this by running `ls -l /dev/disk/by-id`,
      # and copy the long string into the spot below.
      keyFile = "/dev/disk/by-id/REPLACE-HERE";

      # Use this if you want to fallback to the encryption password
      # when the drive can't be found. HIGHLY RECCOMENDED!!!!
      fallbackToPassword = true;
    };
  };
};

Now just setup your configuration and run nixos-install

And that is it! Full Disk Encryption and remote unlocking with a flash drive.
Again if your looking for more info or run into any issue check the two links at the top of this guide.

This has been Jasper, until next time 👋

What Language Should I Choose?

Jasper — Fri, 11 Oct 2024 11:49:14 +0000

Whether your just getting started with programming or you have been learning for many years now, the most common question you have probably asked yourself is: What language should I choose?
I asked myself that question quite often for a long time, but now I have the answer and I'm here to tell you it!

1. Consider What You Enjoy

Maybe it sounds obvious but, how much you enjoy writing/testing/debugging in a language plays a huge role in your confidence and in turn ability to code with that tool-set.
When you find a language piquing your interest you want to learn more and more about it, you get that drive to dive deeper and deeper down the rabbit hole.

One language that really gave me that feeling was Gleam, it managed to wrap everything I liked about languages such as JS, Rust and even Java into one brilliant type-safe package.
Not for a long time before I met Gleam had I wanted to try creating so many different things just to get to the bottom of how this language ticked, as it were.

So let's say you want to do web development, you watched some YouTube's and all the cool kids are using React and Next.JS, maybe you decided you would go another route like Golang with HTMX. Whatever it is, you have inadvertently joined a cult, welcome!

All jokes aside the framework or language you start with can typically stick with you the longest, like Javascript or perhaps Python. From that point you have options, you could do what I did and just follow demand or like some others have done and just tried absolutely everything their language had to offer (that means all frameworks too).

Maybe you decided you would stick a limb out and jump on the Rust bandwagon, ride off into the sunset and crash into the borrow checker inevitably a few hundred times.

The point I want to make is, if you have an itch for a certain language or tool, go ahead and try it. And once you find something you love, stick to it!

2. Demand in the Industry

The second key decider is simple: Is it in demand?

When choosing a language or framework, you want to make sure your skills align with industry needs, unless you're freelancing. Freelance work typically gives you more flexibility in your choice of tech stack since, at the end of the day, clients care more about results than the tools used to get them. For instance, Martha who just wants to share her 56 cats with the world via a blog that automatically gets cat photos from her phone and posts them will not understand the difference between a backend in Rust or VisualBasic when she is using her site. If it works, it works. If you love what your doing, your on the right track.

If though your looking to join the next big unicorn startup, it's worth understanding the tech trends in your desired industry. A large amount of startups have been using Javascript frameworks like React or it's many delineations such as Next.js or Remix. So your best bet will be learning as much as you can about Javascript and trying out a few frameworks for yourself.

If your looking for maybe a more backend focused position though at a startup I have heard Golang is becoming more and more popular, but make sure to check your facts!

In general my advice is, if your going freelance, do exactly what you want to do! Use Rust and Dioxus, use Gleam and Lustre, use Python and Django, whatever your heart desires follow it.
If you though want to go after startups or just a company in general, do some research into companies in your local area if that is an option where you live or start doing market research into the most sort positions and compare the requested skills with what you enjoy, that will help you make a better guided decision.

3. The Importance of Experimentation

Ultimately, there’s no substitute for hands-on experience. One of the best ways to learn and grow as a developer is by trying different languages and frameworks. Each one will teach you new concepts and offer unique insights into how problems can be solved.

Over the years, I've gone from Java to JS, dipped my toes into Rust, and many others, all while picking up knowledge along the way. The more languages you experiment with, the broader your problem-solving toolkit becomes. Concepts like concurrency in Go, type safety in Rust, or the asynchronous, non-blocking, dare I say rage inducing, nature of JavaScript all build your understanding and make you a more versatile developer.

If you’re interested in a language other than the one your currently the best at, give it a go! The only way to know if you like something is to try it.

Final Thoughts

When deciding which language or framework to learn next, balance personal enjoyment with practicality. If you like a language, you'll naturally lean toward mastering it. At the same time take a good look for the opportunities available for you and how they align with your interests.

No matter what you choose, whether it's diving deeper into a familiar stack or venturing into new territory with a brand new language, the key takeaway is this: Experiment, learn, and apply. Every language you learn contributes to your growth as a developer, and in the end, it’s not about the language itself but how well you can use it to solve problems and in turn make the world a better place.

This has been Jasper, until next time 👋

The Cleanest Icons for your next README.

Jasper — Fri, 16 Aug 2024 07:08:05 +0000

Just a quick post today but one I really wanted to make.

A while ago I came across a repository called DevIcons and instantly fell in love with the clean pastel colors on the minimalist iconography.

Nighty3098 / DevIcons

Dev icons

Ctrl+F to find the badge

icon	Badge name	link
	Portfolio	Open
	Discord server	Open
	Blog	Open
	LinkedIn	Open
	Site	Open
	Tech Support	Open

Social

icon	Badge name	link
	Reddit	Open
	Telegram	Open
	Discord	Open
	Signal	Open
	x	Open
	YouTube	Open
	LinkedIn	Open
	Matrix	Open

Languages

icon	Badge name	link
	BASH	Open
	C++	Open
	C	Open
	CSS	Open
	HTML	Open
	JS	Open
	Markdown	Open
	Python	Open
	TypeScript	Open
	rust	Open
	lua	Open
	ruby	Open
	php	Open
	gleam	Open
	java	Open
	golang	Open

icon	Badge name	link
	SQL	Open
	SQLite	Open
	MySql	Open
	firebase	Open
	pocketbase	Open
	supabase	Open

Dev

icon	Badge name	link
	Docker	Open
	Dev To	Open
	sfml	Open
	QT	Open
	react	Open
	Api	Open
	Git	Open
	SvelteKit	Open
	gitlab	Open
	stack_overflow	Open
	prisma	Open
	HackTheBox	Open
	Jupyter	Open
	OpenSource	Open
	postman	Open
	laravel	Open
	ton	Open

Apps

icon	Badge name	link
	replit	Open
	inkdrop	Open
	spotify	Open
	Notion

…

View on GitHub

I have seen many, many, MANY, icon libraries in an attempt to find one suitable for myself, but never before until now have I found one that I could say was the best.
Just recently too 5 new icons were added! (at my request ;3)

Just a quick shout out but I think a lot of Minimalists like myself will value this post.
Thanks all and catch you next time,
Jasper

I Changed My Mind - NixOS is NOT the Best Linux

Jasper — Sun, 11 Aug 2024 01:46:12 +0000

Well I didn't expect to be writing this post, ever.

Most of my posts on here have just been NixOS and praising its glory to all but recently I have been greatly disliking NixOS more and more.

But what does this mean for you? It could mean nothing, or it could mean everything...

NixOS Pros

I can't say NixOS isn't great, it has so many amazingly useful features that just make using Linux so much easier.

All packages are version locked. (Easy to roll back versions)
All package dependencies are per package so version conflicts are prevented.
Thousands of services are now easily configurable from the ground up thanks to NixOS Options.
It provides a similar format to docker in that your whole system is a container that can be perfectly and precisely replicated anywhere!

These have been the reasons I stuck with NixOS for the past year.
But the way NixOS does some of these things has also been its downfall for me.

NixOS Cons

The greatest problem I have experienced with NixOS is actually development.
Working with anything that requires external libraries like C, Java or even Rust has been so much of a pain I have just given up on projects because of it.

But what is the problem exactly?
NixOS makes it very difficult to simply, install a library and have it accessible to the rest of your system.

On Arch setting up a OpenGL environment for C is as easy as:

sudo pacman -S gcc cmake make glfw glew libglv

On NixOS you can't just add these packages to your package list and call it a day, you need to setup whatever LD_LIBRARY_PATHs are and even then I couldn't get it to work.

It turns a simple idea of, "Hey I'm going to have a crack at some C and write a OpenGL program", to, "I literally don't understand how to even get this setup, at this point I haven't even wrote any code and I'm burnt out".

I got so fed up I started looking into switching Distro's entirely.
"Where did that lead you, back to me" - Arch Linux"

Arch, dangerous but simple

Now don't worry I'm not actually abandoning NixOS. But I will be using an Arch Virtual Machine to do any kind of graphics or library dependent development.

Thanks to my guide on installing Arch is was really easy to setup and like I illustrated earlier it took my around 30 seconds to get my environment ready and I could just start coding, wonderful!

Arch does make it slightly more tedious to setup the actual operating system, but its a sacrifice I can make for being able to quickly spin up any development environment I want.

Conclusion

Arch makes the operating system tedious, but the development environment easy.
NixOS makes the operating system easy, but the development environment torture.

It really seems like there is no perfect Linux distribution. Not yet at least.

Until next time, thank for tuning in.
Jasper out.

This Language has just Solved Concurrency in your Backend Services.

Jasper — Sun, 21 Jul 2024 04:37:55 +0000

Ok Jasper what is this post about, wait it isn't NixOS.

That's right, today I'm covering my new love language Gleam, "a friendly language for building type-safe systems that scale".

So not long ago I was scrolling through YouTube and on my home page I saw this video by Isaac Harris-Holt. And I was blown away, "Wait I don't have to use Rust to make highly performant non-crashing services?".

I immediately fell in love with the language and proceeded to the Gleam Language Tour and besides the SvelteKit Tutorial, this is the best language guide I had ever seen. After only 2 days I felt I had a full grasp on the language.

"Ok Jasper cool, you have a crush on a new vague language I have never heard on, why do I care again?"

You care, my friend, because you no longer have to learn Rust to ensure your backend doesn't crash and you don't need to learn Go for high concurrency. You get both benefits in just one language.

And before anyone decides to smoke me in the comments, I do understand that Go and Rust are lower level languages whereas Gleam is sort of a mid-level language as it runs on the BEAM Virtual Machine.

However I have seen the great argument that the only way to make a backend that doesn't crash is with something like Rust for ultimate type-safety and protection from memory errors (which isn't foolproof). But after using Gleam for around a month I can say you really don't need Rust for that, Gleam has incredible type safety and the fault tolerance of the Erlang runtime to power it in creating efficient and scalable backend infrastructure.

I mean WhatsApp uses it, it must be good! (this is a joke lol)

With Gleam's recent v1.3 release we now have auto-import for the LSP which is a great assistance to developers, aswell as many more features.

If it wasn't already clear this is a very opinionated post but I really just wanted to share this language and help get others into it because I truly believe this language will help power the future of backend development. Typescript has to die soon right?

So if this post interested you at all please check out Gleam and Isaac's channel because I think he is single-handedly providing the best gleam education currently available.

That's all from me this post, until next time.

The Definitive Guide to Installing Arch Linux

Jasper — Thu, 18 Jul 2024 23:26:47 +0000

My better judgement told me not to make this post. But here we are, a definitive, beginner friendly guide to install Arch Linux.

Before we continue I just wanted to give everyone a little back story as to my Arch Linux adventures. Well starting off, Arch was my very first Linux distribution. Yeah I didn't start with something easy like Ubuntu or Linux Mint.

And the only reason I somewhat survived this is because of the amazing help of an old friend @SolomonTech. He is the craziest Linux user I know and he has mained Arch Linux for the last 4+ years. And Sol if you read this, I am writing this guide in your memory.

Alright so back to the actual reason for this post, installing Arch Linux.

Updated as of: July 2024

Creating the Live ISO

Ok so let's download the ISO and flash it to a spare 8-16GB USB.
First download the arch ISO from this link, scroll down to the countries and find your closest one, download the file ending with .iso

Linux Users

Check lsblk for your USB flash drive, for example mine will be /dev/sdb
Still in the terminal navigate to the folder where the ISO is and run:

sudo dd bs=4M if=archlinux.iso of=/dev/sdb status=progress oflag=sync

Make sure to change archlinux.iso to the file name of the ISO you just downloaded and change /dev/sdb to your flash drives identifier.

Windows Users

Get Rufus
Install Rufus, select the ISO and your flash drive and click Start, then run in ISO mode. You don't need to change any other settings.

Ok so now that we have our boot-able flash drive let's plug it into the computer you want to install Arch on and reboot it.
I'm sure for anyone reading this you do know how to do stuff like entering BIOS and booting a flash drive but for those who are not familiar just hold DEL or F12 on your keyboard whilst your computer is turning on to bring up the boot menu, this key can be different depending on your motherboard so if your having trouble lookup the motherboard brand to find the key to open the "Boot Menu".

From there select your flash drive, then when the Arch installer boots just press enter on the first option.

You should have been greeted with "Welcome to Arch" or something similar and now be in a terminal with some instructions printed at the top.

Networking

If you have a ethernet cable connected to your computer, internet will work out of the box but if you have Wi-Fi only stick around for this next short bit.

# Enter the IWD shell by typing:
iwctl

#
# BEGIN IWD SHELL COMMANDS
#

# List your wireless devices
device list

# Replace $NAME with the name of your wifi device

# Power on your adapter if it isn't already
device $NAME set-property Powered on

# Scan for networks and list them
station $NAME get-networks

# Remember the SSID value outputted here

# Connect to an available network with password
station $NAME connect $SSID

# Should have been successful, exit shell
exit

#
# END IWD SHELL COMMANDS
#

And with that you should be connected, if your not for any reason please check out the Arch Wiki on IWD and Networking.

Partitioning

Before we jump right into partitioning though let's set our timezone.

# List available timezones, Navigate the list using `j` for down `k` for up and `q` to exit.
timedatectl list-timezones

# Replace Country and City with yours
timedatectl set-timezone Country/City

Now we can partition,
However I need to explain some basic fundamental concepts of drive labels.
All drives are prefixed with /dev/
SATA Drives like SSD's or HDD's will always be /dev/sdX the X is a letter between A and Z to identify your drive.
So the first SATA drive will always be /dev/sda and the second might be /dev/sdb

SATA drives show their partition number by a number right after the label, so partition 1 on /dev/sda would be /dev/sda1 and so forth.

NVME Drives or M.2 drives will always be /dev/nvme0nX where X is the number that orders these drives. So if you have 2 NVME drives and want the second one that would be /dev/nvme0n2

NVME drives show their partition number by a p then a number right after the label, so partition 1 on /dev/nvme0n2 would be /dev/nvme0n2p1 and so forth.

# Find your drive identifier
lsblk

# You can typically tell which drive is the one 
# you want to install on by the size and whether 
# it is `nvme` being a M.2 drive or `sdX` being 
# a SATA drive as explained earlier

# Going forward I'll be using `/dev/sda`

# Enter the fdisk utility
fdisk /dev/sda

#
# BEGIN FDISK COMMANDS
#

# Create a new GPT label
Command: g

# Print the current partition table
Command: p

# If any partitions exist just press `d` and Enter until they are all gone.

# Create a new EFI boot partition
Command: n
Number: 1
Primary or Extended: p
First Sector: Enter
Last Sector: +1G

# Now select the EFI system type
Command: t
Number: 1
# Type capital L to see all types, EFI System should
# be the first
Partition Type: 1

# Create a new swap partition
Command: n
Number: 2
Primary or Extended: p
First Sector: Enter
Last Sector: +4G

# Now use the Linux swap type
Command: t
Number: 2
# Type capital L to see all types, Linux swap should
# be number 19
Partition Type: 19

# Create the root partition
Command: n
Number: 3
Primary or Extended: p
First Sector: Enter
Last Sector: Enter

# Use Linux root x86-64 type
Command: t
Number: 3
# Type capital L to see all types, Linux root x86-64 
# should be number 23
Partition Type: 23

# Now save changes and quit
Command: w

#
# END FDISK COMMANDS
#

Now running fdisk -l should show the following

Finally we need to format these partitions.

# Format the root partition
mkfs.ext4 /dev/sda3

# Format the swap partition
mkswap /dev/sda2

# Format the EFI partition
mkfs.fat -F 32 /dev/sda1

# Now mount the drives
# Mount the root partition
mount /dev/sda3 /mnt

# Mount the EFI partition to boot
mount --mkdir /dev/sda1 /mnt/boot

# Turn on swap for the swap partition
swapon /dev/sda2

Congrats you are now half way through!

Installing to the Drive

First we need the closest servers for the package manager so we have the best speeds.

Quick heads up for Vim usage, press i to enter insert mode, ESC to exit insert mode, and :wq to "Write" and "Quit".

# Replace AU with your country identifier
curl -s "https://archlinux.org/mirrorlist/?country=AU&protocol=https&use_mirror_status=on" > /etc/pacman.d/mirrorlist

# Edit the mirrorlist file and un-comment the lines # with Server, see the example below
vim /etc/pacman.d/mirrorlist

# Exit vim with :wq when your done

As an example change this:

## Australia
#Server = https://syd.mirror.rackspace.com/archlinux/$repo/os/$arch
## Australia
#Server = https://sydney.mirror.pkgbuild.com/$repo/os/$arch
## Australia
#Server = https://au.mirrors.cicku.me/archlinux/$repo/os/$arch
## Australia
#Server = https://mirror.aarnet.edu.au/pub/archlinux/$repo/os/$arch
## Australia
#Server = https://archlinux.mirror.digitalpacific.com.au/$repo/os/$arch
## Australia
#Server = https://gsl-syd.mm.fcix.net/archlinux/$repo/os/$arc

To this:

## Australia
Server = https://syd.mirror.rackspace.com/archlinux/$repo/os/$arch
## Australia
Server = https://sydney.mirror.pkgbuild.com/$repo/os/$arch
## Australia
Server = https://au.mirrors.cicku.me/archlinux/$repo/os/$arch
## Australia
Server = https://mirror.aarnet.edu.au/pub/archlinux/$repo/os/$arch
## Australia
Server = https://archlinux.mirror.digitalpacific.com.au/$repo/os/$arch
## Australia
Server = https://gsl-syd.mm.fcix.net/archlinux/$repo/os/$arc

Now our mirrors are setup lets install all the core packages into the new system.

# Install linux kernel and firmware
pacstrap -K /mnt base linux linux-firmware sudo vim dhcpcd networkmanager

# Generate fstab from system config to new system
genfstab -U /mnt >> /mnt/etc/fstab

Final Steps

Now we are ready to switch into the new install via arch-chroot and set the final things up.

# Chroot into the new system
arch-chroot /mnt

#
# BEGIN CHROOT COMMANDS
#

# Copy timezone info, replace Country and City
# just like before
ln -sf /usr/share/zoneinfo/Country/City /etc/localtime

# Sync clock
hwclock --systohc

# Generate locals
locale-gen

# Set your system hostname, this will be your 
# systems name on the network and show in the terminal
# like `user@hostname`
echo $HOSTNAME > /etc/hostname

# Generate initramfs image
mkinitcpio -P

# Set root user password
passwd

# Install packages for bootloader and networking in 
# the new system
pacman -S grub efibootmgr

# Mount the EFI partition
mount /dev/sda1 /boot

# Install grub
grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=grub-boot

# Intialize bootloader configuration
grub-mkconfig -o /boot/grub/grub.cfg

# All done, exit the chroot
exit

#
# END CHROOT COMMANDS
#

That is it! Now just run the following before rebooting.

# Umount drives
umount -R /mnt

# Reboot!
reboot

When your screen turns off you can unplug the USB and hold the boot menu key, then select Arch.

Once in you will be prompted with a login screen, enter root for the user and whatever the password is you set earlier.

Congrats you are now in your new Arch Linux system!

Post Install Notes

Now if I covered everything for the post install this guide would be go on forever so I'll just cover the important things.

Now that your logged in as root run:

systemctl start dhcpcd.service

# IF ETHERNET
# Get the name of your adapter, example: enp0s3
ip link

# Start it and the dhcpcd service
ip link set enp0s3 up
systemctl enable dhcpcd@enp0s3.service

# IF WIFI
systemctl enable NetworkManager
systemctl start NetworkManager
# In the TUI do Activate a connection
nmtui

Last thing we need to do is create a user and give it privileges.

# Create user with wheel group and bash shell
# Replace $USERNAME with yours
useradd -m -G wheel -s /bin/bash $USERNAME

# Set the password for the user.
passwd $USERNAME

# Edit the sudoers file so the user has perms
EDITOR=vim visudo

# Add the following to a new line
%wheel ALL=(ALL:ALL) ALL

# Exit and save with
:wq

Now you can exit and login to your new user with sudo permissions! Start installing some packages with sudo pacman -S.

I hope you enjoyed and benefited from this guide, again huge shoutout to my man SolomonTech.
If you liked this post please leave a like and maybe even a comment, I love responding to them all!

Until next time, bye!

Self Hosting Supabase with Docker - Guide

Jasper — Tue, 09 Jul 2024 05:15:12 +0000

Self Hosting Supabase

This is a quick guide for self hosting Supabase, of course.
If I'm being honest the official guide is pretty bad so I'm going to try to make this better.

Prerequisites

A knowledge of how to use the terminal
A server with at least 2GB of RAM
A knowledge of your server's IP address

Installing Supabase

I assume you can login to your server via SSH and have docker and git installed.
If not check your distribution's documentation for how to install them.

# Change into your home directory
cd ~

# Clone the supabase repo
git clone --depth 1 https://github.com/supabase/supabase ~/temp-supabase

# Make your project directory
mkdir ~/supabase-project

# Copy over the docker stuff
cp -rf ~/temp-supabase/docker/* ~/supabase-project
cp -rf ~/temp-supabase/docker/.env.example ~/supabase-project/.env


# Change into the supabase directory
cd ~/supabase-project

# Download the docker images
docker compose pull

Now we need to modify the .env file to setup JWT secrets and studio credentials.

Head to Generate JWT Secrets and generate a 32 or 64 character secret.
Copy the secret into the JWT_SECRET field in the ~/supabase-project/.env file.

Now go to this link and switch to the decoded tab. Change the token under verify signature to you JWT token you just generate earlier. Save the output on the left as SERVICE_ROLE_KEY in your .env file.

Now for the ANON_KEY go to this link and repeat the step before, replace your-secret-key-HERE with the JWT key you generated before, and put the generate string for the value ANON_KEY in the .env.

Generate 1 more JWT key that is 32 chars for the POSTGRES_PASSWORD on Generate JWT Secrets and put the generated string for the value POSTGRES_PASSWORD in the .env.

Last thing before we start the docker containers is to setup a username and password for the studio page.

Do this by changing DASHBOARD_USERNAME and DASHBOARD_PASSWORD in the .env file.

Now we can start the docker containers.

# Start the supabase instance in the background
cd ~/supabase-project
docker compose up -d

# Stop the supabase instance
docker compose down

Now you can access the studio at http://your-server-ip:3000 and login with the username and password you set in the .env file.

Accessing the Database

If your using a ORM like Prisma or Drizzle you will probably want to access the database directly.
To do these use the following URL:

Note:
POSTGRES_DB defaults to postgres

postgres://postgres:[your-POSTGRES_PASSWORD]@[your-server-ip]:5432/[POSTGRES_DB]

The Ultimate NixOS Homelab Guide - Flakes, Modules and Fail2Ban w/ Cloudflare

Jasper — Tue, 02 Jul 2024 02:17:39 +0000

Welcome back everyone to the NixOS homelab guide, today we will be moving all our configurations into a very simple flake, setting up Vaultwarden with Fail2Ban and finally modularizing our configuration ready for future self hosted apps.

Sorry for the huge wait, I had some issues and personal problems that cropped up but I'm back!

Flake Setup

Moving our configuration to a flake is pretty easy so let's get straight to it.

Make a new directory in your home folder.

mkdir ~/.flake
cd ~/.flake

Now create a new flake.nix file at the root of that directory and open it in your text editor of choice.

vim flake.nix

Now fill out the file with the following, then I'll explain and break it down.

{
  description = "A very basic flake";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
  };
  outputs = {
    self,
    nixpkgs,
    ...
  } @ inputs: let
    system = "x86_64-linux";
    version = "24.11";
    user = "your-username";
    hostname = "homelab";
    pkgs = import nixpkgs {
      inherit system;
      config = { allowUnfree = true; };
    };
    lib = nixpkgs.lib;
  in {
    nixosConfigurations = {
      ${hostname} = lib.nixosSystem {
        inherit system;
        specialArgs = { inherit user hostname version; };
        modules = [
          ./nix/configuration.nix
        ];
      };
    };
  };
}

We initialize a flake, add the unstable nixpkgs source, set some variables we can use through our entire config (make sure to set the hostname and user variables to whatever username and hostname you used in your configuration.nix, we set that file up in the last post) and then create the nixosSystem inheriting our variables and then importing configuration.nix which we will move into our flake directory right now.

mkdir ~/.flake/nix
sudo cp /etc/nixos/* ~/.flake/nix
sudo chown $USER:users ~/.flake/nix/*
sudo chmod a+rw ~/.flake/nix/*

Those commands will copy our existing configurations to our new flake directory and then make sure our user have all the write permissions.

You should now have this directory structure.

~/.flake
├── flake.nix
└── nix
    ├── configuration.nix
    └── hardware-configuration.nix

Now we need to update our configuration.nix to work with our flake and also add some utilities.

{ config, lib, pkgs, user, hostname, version, ... }:

{
  imports =
    [ # Include the results of the hardware scan.
      ./hardware-configuration.nix
    ];

  boot = {
    kernelPackages = pkgs.linuxPackages_latest;
    loader = {
      efi.canTouchEfiVariables = true;
      grub = {
        enable = true;
        efiSupport = true;
        device = "nodev";
      };
    };
  };

  nix = {
    # Enable flakes!
    settings = {
      experimental-features = [ "nix-command" "flakes" ];
      auto-optimise-store = true;
    };
  };

  nixpkgs.config.allowUnfree = true;

  networking = {
    hostName = "${hostname}";
    networkmanager = {
      enable = true;
    };
  };

  # Your timezone
  time.timeZone = "Australia/Sydney";

  users.users.${user} = {
    isNormalUser = true;
    extraGroups = [ "wheel" "docker" ]; # Enable ‘sudo’ for the user with wheel.
    home = "/home/${user}";
    shell = pkgs.zsh;
  };

  programs = {
    # Personal preference
    zsh.enable = true;

    nh = {
      enable = true;
      flake = "/home/${user}/.flake";
    };
  };

  environment.systemPackages = with pkgs; [
    vim
  ];

  # Enable the OpenSSH daemon.
  services.openssh.enable = true;

  system.stateVersion = "${version}";

}

Now our config will make use of the user, hostname and version variables we created in our flake.nix.

Now we are finally ready to apply our new config, run the below command. (replace homelab with whatever the hostname variable is in your flake.nix)

sudo nixos-rebuild boot --flake /home/$USER/.flake#homelab

If any errors come up please leave a comment below and I'll be happy to help troubleshoot.
If the command completes and there were no issues then you can just run sudo reboot.

Fail2Ban and Modularization

In this example I am setting up Fail2Ban for a local Vaultwarden server, you will need to adapt this based on the Fail2Ban instructions for your software.

Let's start and creating a folder at ~/.flake/nix/modules

mkdir ~/.flake/nix/modules

In there let's open up a new file and you can name it either fail2ban.nix or vaultwarden.nix if that is the service you are protecting. (name doesn't matter that much its just semantics).

In that file start with this content:

{ pkgs, lib, config, user, ... }:

{
  services.fail2ban = {
    enable = true;
  };
}

Throughout this I'll be referring to these pages:
https://nixos.wiki/wiki/Fail2ban
https://github.com/dani-garcia/vaultwarden/wiki/Fail2Ban-Setup
https://github.com/fail2ban/fail2ban/blob/master/config/action.d/cloudflare.conf

Now I assume if your setting up Fail2Ban you understand how it works and what it is, so you may be asking, alright so how can I create stuff like Jails and custom actions and filters.

Well Nix has you covered. Let's take a look at my Jail configuration for Vaultwarden.

{ pkgs, lib, config, user, ... }:

{
  services.fail2ban = {
    enable = true;
    jails = {
      vaultwarden.settings = {
        enabled = true;
        filter = "vaultwarden";
        action = ''
          cf
          iptables-allports
        '';
        # This is the path where I have my vaultwarden data
        logpath = "/home/${user}/vaultwarden/vw-data/vaultwarden.log";
        # User gets banned after 4 incorrect attempts
        maxretry = 4;
        bantime = "52w";
        findtime = "52w";
        chain = "FORWARD";
      };
    };
  };
}

"Ok awesome but what is the cf action and what about the vaultwarden filter, how do i set that up on NixOS when /etc is read-only?"

Fear not because here is environment.etc

{ pkgs, lib, config, user, ... }:

{
  environment.etc = {
    "fail2ban/filter.d/vaultwarden.local".text = pkgs.lib.mkDefault (pkgs.lib.mkAfter ''
      [INCLUDES]
      before = common.conf

      [Definition]
      failregex = ^.*Username or password is incorrect\. Try again\. IP: <ADDR>\. Username:.*$
      ignoreregex =
    '');
  };

  services.fail2ban = {
    # ...
  };
}

You may recognise that string for the first child of etc it is the fail2ban path for custom filters!

Now let's add the cf action which is for banning through Cloudflare. You only need this if you have made your Vaultwarden instance public via Cloudflare/-Tunnels.

  environment.etc = {
    "fail2ban/action.d/cf.conf".text = pkgs.lib.mkDefault (pkgs.lib.mkAfter ''
      [Definition]

      actionstart =
      actionstop =
      actioncheck =

      actionban = /run/current-system/sw/bin/curl -s -o /dev/null -X POST \
            -H "X-Auth-Email: <cfuser>" \
            -H "X-Auth-Key: <cftoken>" \
            -H "Content-Type: application/json" \
            -d '{"mode":"block","configuration":{"target":"ip","value":"<ip>"},"notes":"Fail2Ban <name>"}' \
            "https://api.cloudflare.com/client/v4/user/firewall/access_rules/rules"

      actionunban = /run/current-system/sw/bin/curl -s -o /dev/null -X DELETE -H 'X-Auth-Email: <cfuser>' -H 'X-Auth-Key: <cftoken>' \
            https://api.cloudflare.com/client/v4/user/firewall/access_rules/rules/$(/run/current-system/sw/bin/curl -s -X GET -H 'X-Auth-Email: <cfuser>' -H 'X-Auth-Key: <cftoken>' \
            'https://api.cloudflare.com/client/v4/user/firewall/access_rules/rules?mode=block&configuration_target=ip&configuration_value=&page=1&per_page=1' | tr -d '\n' | cut -d'"' -f6)

      [Init]
      cftoken = your-token

      cfuser = jasper-at-windswept@example.com

    '');
  };

Again you can see that the initial string just references the path as a child of /etc. It should be pretty conclusive from there how to add your own actions and filters.
And if ever in doubt, check the NixOS Wiki and search.nixos.org for options relating to fail2ban.

As a side note, getting this to work took me literal days so yeah, haha.

Now to get this to work in our config add the following to your configuration.nix

{ config, lib, pkgs, user, hostname, version, ... }:

{
  imports = [
    ./hardware-configuration.nix
    ./modules/vaultwarden.nix
  ];
}

Now since we moved to a flake and I snuck nh into your configuration you can run the super simple command:

nh os switch

This will rebuild your system and switch over to it automatically based on the flake path we provided earlier, ~/.flake

Securing your Server

Well this is a pretty big post now isn't it.
The best way I secure my server is by disabling SSH via password and only allowing my personal private key.

This can be done as follows:

On your personal computer (the one with your private key)

ssh-copy-id -i ~/.ssh/private_key.pub admin@your.homelab.ip.address

You should also change your ~/.ssh/config on your PC to use that private key when connecting to your homeserver.

Host your.homelab.ip.address
  IdentityFile ~/.ssh/private

KEEP A LOGGED IN TERMINAL TO YOUR SERVER OPEN BEFORE REBUILDING WITH PASSWORDS DISABLED AS IF ANYTHING GOES WRONG YOU WILL BE LOCKED OUT!!!

On your homeserver open up ~/.ssh/authorized_keys and copy the newly created string.

configuration.nix

{
  users.users.${user} = {
    # ...
    openssh.authorizedKeys = [
      # Paste your key into double quotes here
      # Example:
      "ssh-ed25519 AAAA------------ jasper@nixos"
    ];
  };

  services = {
    openssh = {
      enable = true;
      settings = {
        PasswordAuthentication = false;
      };
    };
  };
}

Then rebuild, this time though we will use the boot option and restart the server.

nh os boot
reboot

Now on your personal computer, open a new terminal and try to connect to the server via SSH. If you connect with the password being requested then hurray, you have just secured your server!

If you have any troubles please leave a comment or contact me on Discord (jasper-at-windswept) and I will try to help out!

That is all for this post, make sure to follow and like the post if you found it helpful and I will see you all in the next one.

The Ultimate NixOS Homelab Guide - The Install

Jasper — Fri, 03 May 2024 07:19:01 +0000

Finally after 2 weeks here we are. A full, in-depth, step-by-step, ultimate guide to NixOS for homeservers!

This first post wont be too long but will cover the following:

Installing NixOS
Starting a Basic Config

Well without further a due, lets get this series rolling!

Installation

Just about all of the following is straight from the NixOS Manual so if you need any extra help you can check there or ask a comment below this post and I'll try to help out!

Getting a NixOS flash drive

Ok so let's download the ISO and flash it to a spare 8-16GB USB.
First download the nixos-unstable ISO from this link.

Next for Linux users just do the following:

Check lsblk for your USB flash drive, for example mine will be /dev/sdb
Still in the terminal navigate to the folder where the ISO is and run:

sudo dd bs=4M if=nixos-unstable.iso of=/dev/sdb status=progress oflag=sync

Make sure to change nixos-unstable.iso to the file name of the ISO you just downloaded and change /dev/sdb to your flash drives identifier.

For Windows user:

Get Rufus
Install Rufus, select the ISO and your flash drive and click Start, then run in ISO mode. You don't need to change any other settings.

Ok so now that we have our boot-able flash drive let's plug it into our server and turn it on.
I'm sure for anyone reading this you do know how to do stuff like entering BIOS and booting a flash drive but for those who are not familiar just hold DEL or F12 on your keyboard whilst your server is turning on to bring up the boot menu, this key can be different depending on your motherboard so if your having trouble lookup its brand to find the key to open the "Boot Menu".

From there select your flash drive, then when the NixOS installer boots just press enter on the first option.

Setup and Partitioning

Since we are not using the graphical installer we will have to do this all in the terminal. As a quick note you need to have a monitor and keyboard connected to your server for the first part of the installation, afterwords you can simply connect via SSH.

I won't be explaining the next few steps in detail as otherwise this post's retention rate will cease to exist but if your interested what everything is doing check the NixOS Manual.

First thing do sudo -i to enter root, this way you won't have to prefix every command with sudo.

If you have a Ethernet cable for your server make sure it is plugged in otherwise lets setup the Wifi as you will need internet in the installer.

Networking

systemctl start wpa_supplicant
add_network
set_network 0 ssid "myhomenetwork"
set_network 0 psk "mypassword"
set_network 0 key_mgmt WPA-PSK
enable_network 0

If all went well you should see something along the lines of below showing that the connection was successful.

<3>CTRL-EVENT-CONNECTED - Connection to 32:85:ab:ef:24:5c completed [id=0 id_str=]

Partitioning

For the following commands if you have a M.2 SSD for your main drive you will use /dev/nvme0n1 instead of /dev/sda, if you have multiple M.2 SSDs you should check lsblk to find the one you want to use.

parted /dev/sda -- mklabel gpt
parted /dev/sda -- mkpart root ext4 512MB -8GB
parted /dev/sda -- mkpart swap linux-swap -8GB 100%
parted /dev/sda -- mkpart ESP fat32 1MB 512MB
parted /dev/sda -- set 3 esp on

Now let's format these partitions.

mkfs.ext4 -L nixos /dev/sda1
mkswap -L swap /dev/sda2
mkfs.fat -F 32 -n boot /dev/sda3

And now finish it off by mounting the correct volumes.

mount /dev/disk/by-label/nixos /mnt
mkdir -p /mnt/boot
mount /dev/disk/by-label/boot /mnt/boot
swapon /dev/sda2

Configuration

Now that all our partitions are setup let's do our initial base configuration.

nixos-generate-config --root /mnt
nano /mnt/etc/nixos/configuration.nix

Want to use Vim? Just do the following to install vim on the live installer.

nix-env -f '<nixpkgs>' -iA vim

Now that we have our base canvas of our configuration ready to be painted upon let's start with some basics.


{ config, lib, pkgs, ... }:

{
  imports =
    [ # Include the results of the hardware scan.
      ./hardware-configuration.nix
    ];

  boot = {
    # Use the latest linux kernel
    kernelPackages = pkgs.linuxPackages_latest;
    # Grub bootloader stuff, no need to change this.
    loader = {
      efi.canTouchEfiVariables = true;
      grub = {
        enable = true;
        efiSupport = true;
        device = "nodev";
      };
    };
  };

  # Allows us to use closed source packages.
  nixpkgs.config.allowUnfree = true;

  networking = {
    # What should your server be on the network?
    hostName = "homelab";
    # Use network manager, makes life easier
    networkmanager = {
      enable = true;
    };
  };

  # Your timezone here
  time.timeZone = "Australia/Sydney";

  # Change `admin` to whatever username you want.
  users.users.admin = {
    # This makes sure the user isn't root.
    isNormalUser = true;
    extraGroups = [ "wheel" "docker" ]; # Enable ‘sudo’ and the use of docker for the user.
    # Set the home directory, also change this to `/home/your-username`
    home = "/home/admin";
    # Use Zsh
    shell = pkgs.zsh;
  };

  # Enable Zsh, this is just personal preference
  programs = {
    zsh.enable = true;
  };

  environment.systemPackages = with pkgs; [
    vim
  ];

  # Enable the OpenSSH daemon, for SSH...
  services.openssh.enable = true;

  # Backup the system configuration when changed
  system.copySystemConfiguration = true;

  # The current unstable version of NixOS
  system.stateVersion = "24.05";

}

This is the minimum of what you need to get started on NixOS. We won't add anything more to this now as it would just take ages longer to install and we want to get in ASAP!

So once your happy with the configuration just run the following commmand.

nixos-install

After a while it will prompt you to set the root password and then voila, you just installed NixOS!

Now just reboot and hop into your new system, don't unplug your keyboard and monitor just yet though, we have a couple more things to do.

Post-Install

Now launched into NixOS login to the root user account since the user you created doesn't have a password yet.
Once logged into root type passwd your-username to set the user password.
Then exit and login to the user account.

For Wifi users you are not done quite yet, follow these steps to login to your network in nmtui.

sudo nmtui
Select Activate a connection
Select your network name and enter the password.
Once connected hit escape a few times and your done!

Congratulations! You have just setup NixOS for your homeserver, in the next post I'll be setting up Nextcloud and organizing our configuration to use modules so stay tuned for the next installment coming next week (hopefully)!

And if you have any suggestions for popular self hosted software you want to see setup on NixOS leave a comment and it might just make it into the series.

Thanks everyone and I'll see you all again soon!

I use NixOS for my home-server, and you should too!

Jasper — Mon, 22 Apr 2024 00:37:36 +0000

As we covered in my last post, NixOS is a amazing Linux distribution for creating stable and declared environments. Now while this is amazing for a desktop setup, it is also perfect for a home-server or home-lab.

Let's take a look at a few ways NixOS makes setting up a home-server so much smoother!

Self Hosting Services

NixOS has gained many integrations from a wide variety of services over the years but here are a few you will probably be interested in.

Jellyfin

Out of the box NixOS provides options to easily setup a Jellyfin instance on your computer, just add the following to your configuration.nix

services.jellyfin = {
  enable = true;
  dataDir = "/home/your-user/jellyfin/data";
  user = "your-user";
};

It is that easy to spin up a fresh instance of Jellyfin and there are even more options all found on search.nixos.org

Vaultwarden

Never before has it been this easy to setup Vaultwarden, a fork of the Bitwarden server with all the features of a paid Bitwarden account!

services.vaultwarden = {
  enable = true;
  dbBackend = "postgresql";
  # Store your variables like admin password here
  environmentFile = "/home/your-user/vaultwarden/.env";
  config = {
    SIGNUPS_ALLOWED = false;
    DOMAIN = "https://vaultwarden.example.com";
  };
};

There are even more options than these though so again make sure to checkout search.nixos.org

Nextcloud

Here we are the big boy himself, Nextcloud.
Of course like all the other popular self hosted services Nextcloud has a large variety of options to get your services up and running.

services.nextcloud = {
  enable = true;
  home = "/home/your-user/nextcloud";
  https = true;
  hostname = "nextcloud.example.com";
  settings = {
    trusted_domains = [
      "talk.nextcloud.example.com"
      "files.nextcloud.example.com"
    ];
  };
};

And for the final time those are just a fraction of the available options to configure Nextcloud through NixOS, so if you need to configure anything else make sure to check out search.nixos.org/nextcloud.

So have I convinced you yet? NixOS really is the easiest way to manage all of your software on your desktop and home-server!

But what about Docker, there are some things that NixOS hasn't packaged yet so how do I use those or any of my other docker services?
Well do not worry, NixOS again makes it super simple to setup docker and even setup Nvidia Toolkit support for containers that want GPU utilization.

virtualisation.docker = {
  enable = true;
  # This option is deprecated and will be replaced 
  # soon but the new option doesn't seem to work 
  # properly yet so you can just use this.
  enableNvidia = true;
};

user.users.your-user = {
  # ...
  extraGroups = [ "docker" ];
  # ...
};

Just like that your ready for anything docker to come, and for those who need to configure docker a bit more, maybe put it in rootless mode, can check out the options on search.nixos.org

Wrapping Up

Well that was easy wasn't it, just a few lines of code and a rebuild later and you could have all of these services up and at it!
This is all well but how do you actually get NixOS and set everything up in the first place?

That is exactly what I'm going to help you do, two weeks from now I'll be getting a new home-server and in a new post, or maybe series of posts, I'll go over everything I do to setup NixOS on my system, so make sure to follow me to stay tuned for those!

Another little promotion but if you are interested in NixOS, your just getting started or even if you are more experienced user, I have a documentation site where I publicly write about tons of issues I come across on my journey through NixOS and exactly how I fixed them.

As well I have a ton of resources linked for learning how to get started with NixOS so make sure to check it out at jasperclarke.com

This distro finally fixes Linux

Jasper — Thu, 18 Apr 2024 00:18:03 +0000

Probably one of the biggest roadblocks for people who want to use Linux is its complexity. And those people are not wrong Linux is quite complex compared to your typical macOS or Windows(eww).

Unless your using Ubuntu then you will most likely find Linux can be quite unstable, just one system update and whoops my Arch setup isn't booting the graphical environment anymore!

That was me during my first two years of Linux, constant issues, every update was like poking a sleeping bear to see if it would wake up, sometimes it did..

But now that the preamble is covered let's talk about what you really came here for. A Linux distro that fixes everything we have covered so far. No more worrying about your system breaking when you update, no more needing to write massive bash scripts to recreate your system if you ever need to install again, no need to write documentation for your own system just so you can remember how you fixed all those issues!

I present to you all, NixOS. A fully declarative distribution, where all packages can be individually controlled and version locked to get exactly what your system needs.

What is NixOS?

Ok well lets break that down, "what do you mean it's declarative?". Well most Linux systems are 'imperative', you have to do many things in succession to accomplish your system which results in those long bash setup scripts we all have seen at least once.

Whereas a 'declarative' system means just about everything in the system is controlled by a few configuration files, "Oh but Jasper that is literally every system, its called dot-files", well yes and no.

Dot-files on most system are your window manager, terminal and other configs but on NixOS you actually combine every single modification to your system in a small set of files or even all of them in one single file!

How NixOS works

Here is a quick example, on most systems to setup your timezone you would have to either run a command or change a system file, just take a look at the Arch Wiki on changing the time. But as you can see below on NixOS its controlled by a single line in your sole system configuration file.

time.timeZone = "Australia/Sydney";

And this is just one example, with NixOS all you need is a single .nix file and your can do just about anything you could do with a few hundred commands on another distro.

And let's say you have made this massive config, well now you can run that config on ANY other system and it will be created the exact same it was on the original system thanks to NixOS's version locking, which we will look at soon.

So once you make a change to your config you just run the nixos-rebuild command and then pass in switch if you want to apply the changes to your system immediately, boot if you want to apply them at the next boot, build if you just want to build without applying any changes and EVEN build-vm which lets you build a virtual machine of your system to test if the changes work without actually testing it on your system.

The last thing I'll mention is that on NixOS whenever you install a package, (which is done by simply adding the package name to your config) that package is version locked and can never change unless you update your system or specify another specific version of the package, no more needing to worry about a package updating and breaking without your knowledge!

Conclusion

After using NixOS myself for a few years now I have never had a single problem with my system that couldn't be easily solved by making a quick change to my config.

While NixOS has a steep learning curve it is well worth it. But don't fear there are alot of great resources on how to start with NixOS.