:fn-container-comment: footnote:[IDK why would someone do this with Bahaghari but whatever, your system, your rules.]
:fn-specialization-comment: footnote:[Which I can see is useful for separating rices and booting into them separately for whatever reason (again, your system, your rules but my guess is because you're a control freak).]
To get started using Bahaghari, you have to set some things up first.
The way how Bahaghari expects you to use it is by choosing one (or more if you want) of the module sets which you can view more details at <<module-sets, its dedicated section>>.
For now, let's assume that you are using Tinted Theming module set in your NixOS configuration which you can set it up with the following code.
// TODO: Change all of the URLs once this moves into its own repo.
First, you'll have to install Bahaghari as part of your Nix project or whatever.
There are multiple ways to do this.
* We'll first start with the increasingly popular method of including Nix dependencies with https://zero-to-nix.com/concepts/flakes[Nix flakes], a built-in way of pinning them dependencies.
Bahaghari has a module set for interacting with Tinted Theming standard schemes and templates.
This module is designed to closely follow Tinted Theming's standard while offering some convenience with the library set.
For example, you can use `importYAML` from Bahaghari's standard library set to easily import standard Base16 schemes into Nix-representable data which you can press onto your Nix configuration.
Bahaghari offers a pre-configured version of already existing modules for NixOS, home-manager, and NixVim quite similar to Stylix's `stylix.targets.<name>` submodules.
To make use of this, you'll have to import Bahaghari module set's
Most notably, the feature I'm looking for is generating multiple colorscheme templates for different applications which is nice for hybrid deployments of home-manager-plus-mutable-configurations (AKA traditional dotfiles) and for mixed installations of NixOS and home-manager (or whatever else that can be combined).
While Bahaghari eventually diverged from nix-colors entirely, it can be used as an alternative specifically with Bahaghari's Tinted Theming module set.
You can replicate nix-colors' preference of allowing a default set of colorscheme by creating a module argument holding the name of the preferred colorscheme.
While Bahaghari can be used similarly to Stylix, it isn't completely 1-to-1 to Stylix as the latter focuses on the holistic side of customization including for fonts and wallpaper.
On the other hand, Bahaghari completely focuses on colorscheme generation. footnote:[While Bahaghari as a project can also focus beyond colorschemes similar to Stylix, it isn't a part of the vision for now.]
Bahaghari also took some cues from Stylix specifically from its Stylix targets which became the pre-templated configurations submodules for each of the design system module set (e.g., Tinted Theming).
[#hacking-this-project]
== Hacking this project
If you want to hack this hack, you can do so with Nix.
This is mostly a Nix project so you only need Nix and you're good to go.
The folder structure of this project should be intuitive but we'll give a recap like a good manager.
Here's the rundown.
* link:./default.nix[./default.nix] is basically the entrypoint for our user and onlookers who're looking to extend Bahaghari.
This is used both by the flake- and non-flake-based setups for consistency (and also easier to maintain).
* link:./lib/[./lib/] is where the Bahaghari library set lives.
It takes a lot of cues from nixpkgs how the library is maintained with individual files separated by purpose and the module sets (most of the time).
* link:./modules/[./modules/] is where the Bahaghari module sets reside.
All of them are then separated by... module sets and are organized by the aforementioned `default.nix`.
* link:./tests/[./tests/] is where the test suites reside.
We'll cover how to interact with the test suite right after this section.
[#testing]
=== Testing
This project comes with a test suite for... testing things.
You know, for the purpose of preventing as much regression and catching as many potential bugs before releasing this for the users.
For the Bahaghari library set, we have a testing infrastructure set all set in link:./tests/[`./tests/`].
This relies on the `lib.debug.runTests` from nixpkgs which is enough for our simple needs of making sure the functions are correct.
To run the test suite, here's one way to do it.footnote:test-setup-assumption[Assuming you have the new Nix CLI and have nixpkgs as part of `NIX_PATH`.]
We also have a test suites for the Nix module sets.
Similarly from the library set testing, it relies on nixpkgs' NixOS test integration.footnote:[For now, we only test these with NixOS since most of Bahaghari is environment-agnostic anyways. We're more concerned if it can used as intended.]
You can test those puppies out with the following command.footnote:test-setup-assumption[]
