Crystal by @namishh · AwesomeWM on Any distro

01. Overview & Architecture

Schema validatedSource pinned

Purpose: AwesomeWM configuration with multiple colorschemes and handcrafted widgets.
Compatibility: Any distro (Server: X11)
Desktop Part: Dotfiles & full rices
Window Manager & Theme: AwesomeWM / Other

02. Installation & Deployment

Before you installThis changes your desktop configuration. Run it as your normal user, never with sudo: it asks for sudo only where a step needs it (listed below).The guided installer shows its plan first. Files it would replace are kept unless you approve. Everything it copies, clones or appends to in your home folder is backed up and verified first, and --rollback restores it. Packages, sudo changes and the other commands listed under Impact are not undone.

Origingithub.com/namishh/crystalPinned to b43ab1d0fd4e · reviewed in this config file

IntegrityEach release from main builds the installers in GitHub Actions and signs them with a GitHub build attestation. Verify your download against the repository, not this website (Option B, step 2). If it does not verify, don't run it.

ImpactRuns the commands listed in the steps below.

RecoveryGuided: backups in ~/.local/state/0xtsoa/backups/, undo with bash install.sh --rollback.Manual: the steps below only write in the download folder or run listed commands.

Option A: manual installAdvanced

Read the source at the reviewed commit, back up, then run each step yourself.

$git clone https://github.com/namishh/crystal ~/0xtsoa-review/namishh-crystal# 1. clone to a review folder

$git -C ~/0xtsoa-review/namishh-crystal checkout --detach b43ab1d0fd4e9f686739a20cdc130c5cfc9d0159# 2. the reviewed commit

Then the steps. Package commands are written for Arch; on other distros use your package manager.

Step-by-step deployment protocol

Step-by-step deployment

1Clone the repository

Shell commands

$git clone --filter=blob:none https://github.com/namishh/crystal

$git -C crystal checkout b43ab1d0fd4e9f686739a20cdc130c5cfc9d0159

$cd crystal

2Follow the upstream README

Shell commands

$xdg-open https://github.com/namishh/crystal#readme

Option B: guided installerRecommended

The same steps as one script for any distro. It shows the plan first, keeps files you already have unless you approve replacing them, and backs up everything it changes in your home folder. Never pipe it into a shell.

$curl -fsSLo install.sh 'https://www.0xtsoa.dev/configs/namishh/crystal/install.sh'# 1. download

$

gh attestation verify install.sh --repo nyharena25/0xTsoa --signer-workflow nyharena25/0xTsoa/.github/workflows/attest-installers.yml

# 2. verify (GitHub CLI 2.49+, signed in)

$less install.sh# 3. read it

$bash install.sh --dry-run# 4. preview: changes nothing

$bash install.sh# 5. install (asks first)

$bash install.sh --rollback# undo the file changes

View script in browserOther options: --force (replace conflicts, backed up first), --yes, --help

04. Documentation & Guide

Source: namishh/crystalRef: b43ab1d0fd

.github/README.md|GitHub Flavored Markdown

Raw Source ↗

Important

New Changes Soon.

Features of config

OS - nixos // arch
WM - awesome - blizzard // aura // hyprland
Shell - zsh
Term - wezterm
Music - ncmpcpp
Comp - picom - fdev31 fork
Editor - nvim v0.9 - my config

Nix

Note

I have written a blog post on setting up Nixos. And for those who are interested in learning about ricing itself, I have a seperate blog post about is. Checkout the Ricing Guide (btw it also got featured in the official unixporn wiki).

The "Textbook" Definition - A Linux distribution based on the Nix package manager and guided by Nix's core principles.

NixOS is a unique distro. Unlike other distros where you store your configurations in ~/.config/ and binaries in ~/.local/bin , nix takes a different approach. Instead you can declaratively define your configuration in .nix files. These nix files can be used to install and configure programs, services, setting up things like xresources, etc. This approach provides a modular system that enables users to share, reuse, and modify their configurations easily.

Sounds Confusing right? Dont worry here let me simplify some things for you.

derivs/
    phocus.nix
    ...
home/
    namish/
        home.nix
        ...
    shared/
        ...
hosts/
    frostbyte/
        hardware-configuration.nix
        configuration.nix
    shared/
        default.nix
overlays/
      default.nix
patches/
pkgs/
flake.nix
nixpkgs.nix
shell.nix

This is the general structure of my dotfiles. I am using a beta feature called flakes and thats the reason why you will sea a file called flake.nix. Let us start with that!

flake.nix

This main file, it consists of two main parts, inputs and outputs. Inputs are Nix dependencies that a flake needs to be built. Each input in the set can be pulled from various sources, such as github, generic git repositories, and even from your local filesystem. All of these inputs are saved in the flake.lock file. Flake outputs are what a flake produces as part of its build. In this case it produces a NixOS configuration.

hosts/ folder

This folder contains configurations for our machines
The frostbyte folder is the main one where my configuration is stored, the shared one contains configurations that would be same for all machines that I am gonna own.

home/ folder

this folder contains the home-manager configuration for different users. Like before shared contains configurations that would be same for all users.
shared contains things like bin files, colors, gtkThemes

derivations

"techincal" definition - 'A derivation is an instruction that Nix uses to realise a Nix package'
In simple words, deriavations are used to install stuff that aren't available in the nixpkg repositories. (atleast that is what i use them for). Make your own derivation in derivs/program.nix and call it in overlays/default.nix

overlays

they are just modifications you do on top of the original program, for example patching st, or using a fork of st from github.

Warning

by no means are the above things I say 100% the truth. I maybe wrong somewhere, if you spot a mistake kindly prompt me to correct it

WOW! NixOS looks so god damn cool! I am just gonna jump right into it

NO. NixOS is hard.Don't be impatient and jump with the hype train. Nix files are complicated to make and can cause high brain damage. I recommend you to start with the nix package manager or using NixOS in a virtual machine instead of ripping apart your hard disk.

I really wanna try out NixOS!

If you that determined, here are some resources to start out

Rices

Aura

Freosan

Blizzard (Do not use)

Glacier

Kawai

Vercel

Note

For screenshots, go to each rice's respective branch. Also I am aware of the fact that none of the rices are themed like they are named. They are all named like that because the words are related to winter / snow which means nix. To get Basic dotfiles, go to the simplefiles branch.

Focus Flake.

This is a very minimal dwm rice I made to quit ricing. This build mainly contains useful patches like xrdb, swallow, awesomebar,scratchpads, etc. The way of patching is so shit with nixos because I had to manually modify each patch to not conflict with the other.

focusflake

Theming

Firefox

Spicetify

Vencord

Phocus

Neofetch

Credits

These are the chads which helped me throughout my short but crazy nix journey!

And of course credits for the guys for their help with my awesome config!

People from who I have ~~stolen~~ taken inspiration for my design.

Feel free to use any code from any branch as long as you will credit me

GitHub Flavored Markdown (github-markdown-css)README snapshot at b43ab1d0fd