google-codejam-solutions

# vim-far
A Far Manager like Color Scheme (Vim/gVim).<br />
Used [cSyntaxAfter][vimorglink] for highlighting operators, brackets.<br />
Download and copy `colors` directory to `{path/to/vim}/vimfiles` and set -> <br />
```vimscript
colorscheme far
```

# gVim

C++<br />
![gVim cpp](https://raw.githubusercontent.com/ssjtux/vim-far/master/img/gui-cpp.png)

Haskell<br />
![gVim Haskell](https://raw.githubusercontent.com/ssjtux/vim-far/master/img/gui-haskell.png)

Python<br />
![gVim Python](https://raw.githubusercontent.com/ssjtux/vim-far/master/img/gui-python.png)


[vimorglink]: https://www.vim.org/scripts/script.php?script_id=3265

 A Far Manager like Color Scheme (Vim/gVim).

vim-far

codewars-solutions

lycuid.github.io

# form-field-hooks (React)
stateful input field hooks built with react-hooks, for ease of validations etc. <small>(This is experimental for now, feel free to pr fixes and upgrades.)</small>



## Attributes and return types
### Input fields:
(`useInput`,&nbsp; `useSelect`,&nbsp; `useTextArea`,&nbsp; `useCheckbox`)<br />

*_Input Parameters:_*

| property | description |
| ------ | ------ |
| attributes: `{}` | valid html input attributes |
| options: <br />`{validations: (attr) => [boolean, string], display: (attr) => boolean}` | these functions are called to<br />set `meta` and while `sanitize()` |
| React | React's imported object (kinda necessary in the current version as it throws hooks related errors, would be fixed in the future) |

*_Output Element:_*

| property | description |
| ------- | ------- |
| attr: `{}` | html attributes |
| meta: `{}` | meta data (stateful)<br />_valid options_ below in `meta` table|
| dispatchAttr:<br />`(...attr) => void` | `setState` for attr |
| dispatchMeta:<br />`(...meta) =>  void` | `setState` for meta |
| dispatchOptions:<br />`(...options) =>  void` | `setState` for options |
| sanitize:<br />`({valid?: boolean, show?: boolean}) => void` | `setState` for meta,<br />_(provided options run in this method)_ |
| fieldType: `string` | type of html field<br />(`input`, `checkbox`, `textarea` etc) |

*_Meta:_*

| property | description |
| ------- | ------- |
| touched: `boolean` | if at all focused |
| dirty: `boolean` | if value changed |
| valid: `boolean` | is valid |
| show: `boolean` | should display |
| <strike>customValidity</strike><br />validationMessage: `string` | error message if `valid` is `false` |

<strong>Note: </strong> validations work side by side with the [ValidityState API](https://developer.mozilla.org/en-US/docs/Web/API/ValidityState) and [Constraint Validation API](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/HTML5/Constraint_validation)

(use `options.validations` instead of the validity API as it might break the behaviour of the hooks' `meta`).



## Examples:
### Import
```jsx
import Form, {
  useInput,
  useSelect,
  useCheckbox,
  useTextArea
} from 'form-field-hooks';
```

### validations and display
```jsx
const InputElement = () => {
  const name = useInput(
    {value: '', name: 'passwd', type: 'password'},
    {
      // this is to set the properties of the field's `meta`
      validations: (attr) => {
        if (attr.value.length < 8) {
          return [false, 'should be atleast 8 characters long.'];
        }
        return [true, ''];
      },
      display: (attr) => {
        if (attr.className && attr.className.includes('hide-input'))
          return false;
        return true;
      }
    }, React
  );

  const { touched, dirty, show, valid } = name.meta;

  // An Example of how `meta can be useful`
  const style = {boderColor: (touched || dirty) && !valid ? 'red' : 'none'};

  return (
    <Fragment>

      {/* Form.Input takes care of not rendering the input if `show` is False */}

      <Form.Input element={name} style={style} react={React} />
      {(
        !meta.valid &&
        meta.validationMessage.length // we get to set this in `options.validations`
      ) ? <ErrorMessage msg={meta.validationMessage} /> : <></>}


      {/* Or using without `Form` */}

      {show && <input element={name} style={style} />}
    </Fragment>
  )
}
```

# Using the Hooks
### 'useInput' (Input field, can be any `<input />` except radio button)
```jsx
const InputElements = () => {
  const name = useInput({value: 'luffy', name: 'name'}, {}, React);

  const isSaiyan = useCheckbox({name: 'isSaiyan', checked: true}, {}, React);
  const isSuper = useCheckbox({name: 'isSuper'}, {}, React);

  // Can be any Input Element
  // (text, checkbox, password, datetime
  // datetime-local, time, phone, checkbox etc)
  return (
    <Fragment>
      <Form.Input element={name} react={React} />
      <Form.Input element={isSuper} react={React} />
      <Form.Input element={isSaiyan} react={React} />
      
      {/** can also use
        * <input {...name.attr} />
        * <input {...isSuper.attr} />
        * <input {...isSaiyan.attr} />
        */}
    </Fragment>
  )
}
```


### 'useSelect' (`<select />` field):
```jsx
  const SelectElement = () => {
    const select = useSelect({value: '', name: 'select'}, {}, React);
    const multiselect = useSelect(
      {value: '', name: 'multiselect', multiple: true},
      {},
      React
    );

    return (
      <Fragment>
        {/*
          * Here the `defaultOption` attr will add
          * an extra null option
          * value: the value of the default option.
          * label: display value for the default option.
          * hideAfter: remove default option on any other value selection.
          */}

        <Form.Select
          element={select}
          defaultOption={{ value: '', label: '--', hideAfter: true}}
          react={React}
        >
          <option value='1'>One Piece</option>
          <option value='2'>Cowboy Bebop</option>
          <option value='3'>Death Note</option>
          <option value='4'>Naruto</option>
        </Form.Select>

        {/** can also use
          * <select {...multiselect.attr}>
          * ...
          * </select>
          */}
      </Fragment>
    )
  }
```

### 'useTextArea' (`<textarea />` field)
```jsx
  const TextAreaElement = () => {
    const description = useTextArea({value: '', name: 'description'}, {}, React);

    return (
      <Fragment>
        <Field.TextArea element={description} react={React} />

        {/** can also use
          * <textarea {...description.attr} />
          */}
      </Fragment>
    )
  }
```

form-field-hooks

My education, interests, professional experience etc.

aboutme

# leetcode-solutions
My leetcode solutions


leetcode-solutions

My Personal X11 Dotfiles (mediocre rice).


dotfiles

# project-euler-solutions
Project Euler Solutions


project-euler-solutions

# ng-bulma-template

empty pwa template with basic screens, login/logout auth methods etc.


Empty PWA template using https://bulma.io/

ng-bulma-template

Visualization for (some) sorting algorithms.

sortvis

Game of Thrones battles app (hiring challenge, data may not be accurate).

![deploy-server](https://github.com/lycuid/got-battles/workflows/deploy-server/badge.svg) ![deploy-client](https://github.com/lycuid/got-battles/workflows/deploy-client/badge.svg)



got-battles

image-gallery

Dragon Ball Z | Avatar Generator.

![build](https://github.com/lycuid/dbz-avatar/workflows/build/badge.svg) ![deploy](https://github.com/lycuid/dbz-avatar/workflows/deploy/badge.svg)




dbz-avatar

# Simple Lambda ZSH Theme.

A very simple and minimalistic `bash` like theme with a lambda prompt (and git integration).

![screenshot](screenshot.png)

---
Licence [MIT](https://opensource.org/licenses/MIT).


simple bash-like zsh theme with lambda prompt and git integration. 

simple-lambda-zsh-theme

cluless.vim
--------
This is a very opinionated color scheme designed to the get the feeling of being in the [***grid***](https://tron.fandom.com/wiki/Grid).
*(This is built on top of the vim port of the [Nord Theme](https://www.nordtheme.com/ports/vim))*

#### C
<img src="https://raw.githubusercontent.com/lycuid/assets/master/cluless.vim/c_on_the_grid.png" width="500" />

#### Golang
<img src="https://raw.githubusercontent.com/lycuid/assets/master/cluless.vim/go_on_the_grid.png" width="500" />

#### Rust
<img src="https://raw.githubusercontent.com/lycuid/assets/master/cluless.vim/rust_on_the_grid.png" width="500" />

#### Python
<img src="https://raw.githubusercontent.com/lycuid/assets/master/cluless.vim/python_on_the_grid.png" width="500" />

#### Haskell
<img src="https://raw.githubusercontent.com/lycuid/assets/master/cluless.vim/haskell_on_the_grid.png" width="500" />


color scheme with grid feels, for vim (personal preference).

cluless.vim

stagit
------

static git page generator.

It generates static HTML pages for a git repository.


Usage
-----

Make files per repository:

	$ mkdir -p htmldir && cd htmldir
	$ stagit path-to-repo

Make index file for repositories:

	$ stagit-index repodir1 repodir2 repodir3 > index.html


Build and install
-----------------

$ make
# make install


Dependencies
------------

- C compiler (C99).
- libc (tested with OpenBSD, FreeBSD, NetBSD, Linux: glibc and musl).
- libgit2 (v0.22+).
- POSIX make (optional).


Documentation
-------------

See man pages: stagit(1) and stagit-index(1).


Building a static binary
------------------------

It may be useful to build static binaries, for example to run in a chroot.

It can be done like this at the time of writing (v0.24):

cd libgit2-src

# change the options in the CMake file: CMakeLists.txt
BUILD_SHARED_LIBS to OFF (static)
CURL to OFF              (not needed)
USE_SSH OFF              (not needed)
THREADSAFE OFF           (not needed)
USE_OPENSSL OFF          (not needed, use builtin)

mkdir -p build && cd build
cmake ../
make
make install


Extract owner field from git config
-----------------------------------

A way to extract the gitweb owner for example in the format:

	[gitweb]
		owner = Name here

Script:

	#!/bin/sh
	awk '/^[ 	]*owner[ 	]=/ {
		sub(/^[^=]*=[ 	]*/, "");
		print $0;
	}'


Set clone url for a directory of repos
--------------------------------------
	#!/bin/sh
	cd "$dir"
	for i in *; do
		test -d "$i" && echo "git://git.codemadness.org/$i" > "$i/url"
	done


Update files on git push
------------------------

Using a post-receive hook the static files can be automatically updated.
Keep in mind git push -f can change the history and the commits may need
to be recreated. This is because stagit checks if a commit file already
exists. It also has a cache (-c) option which can conflict with the new
history. See stagit(1).

git post-receive hook (repo/.git/hooks/post-receive):

	#!/bin/sh
	# detect git push -f
	force=0
	while read -r old new ref; do
		hasrevs=$(git rev-list "$old" "^$new" | sed 1q)
		if test -n "$hasrevs"; then
			force=1
			break
		fi
	done

	# remove commits and .cache on git push -f
	#if test "$force" = "1"; then
	# ...
	#fi

	# see example_create.sh for normal creation of the files.


Create .tar.gz archives by tag
------------------------------
	#!/bin/sh
	name="stagit"
	mkdir -p archives
	git tag -l | while read -r t; do
		f="archives/${name}-$(echo "${t}" | tr '/' '_').tar.gz"
		test -f "${f}" && continue
		git archive \
			--format tar.gz \
			--prefix "${t}/" \
			-o "${f}" \
			-- \
			"${t}"
	done


Features
--------

- Log of all commits from HEAD.
- Log and diffstat per commit.
- Show file tree with linkable line numbers.
- Show references: local branches and tags.
- Detect README and LICENSE file from HEAD and link it as a webpage.
- Detect submodules (.gitmodules file) from HEAD and link it as a webpage.
- Atom feed log (atom.xml).
- Make index page for multiple repositories with stagit-index.
- After generating the pages (relatively slow) serving the files is very fast,
  simple and requires little resources (because the content is static), only
  a HTTP file server is required.
- Usable with text-browsers such as dillo, links, lynx and w3m.


Cons
----

- Not suitable for large repositories (2000+ commits), because diffstats are
  an expensive operation, the cache (-c flag) is a workaround for this in
  some cases.
- Not suitable for large repositories with many files, because all files are
  written for each execution of stagit. This is because stagit shows the lines
  of textfiles and there is no "cache" for file metadata (this would add more
  complexity to the code).
- Not suitable for repositories with many branches, a quite linear history is
  assumed (from HEAD).

  In these cases it is better to just use cgit or possibly change stagit to
  run as a CGI program.

- Relatively slow to run the first time (about 3 seconds for sbase,
  1500+ commits), incremental updates are faster.
- Does not support some of the dynamic features cgit has, like:
  - Snapshot tarballs per commit.
  - File tree per commit.
  - History log of branches diverged from HEAD.
  - Stats (git shortlog -s).

  This is by design, just use git locally.


My fork of https://git.codemadness.org/stagit/

stagit

My personal build of suckless' st. (https://st.suckless.org/)

installed patches:
  - xresources.
  - scrollback.
  - font ligatures.



My Personal fork of suckless' dmenu. (https://tools.suckless.org/dmenu/)

installed patches:
  - xresources.
  - lineheight.
  - center.
  - borders.

manual code changes:
  - additional xresources configs.



dmenu

My personal fork of suckless' dwm. (https://dwm.suckless.org/)

installed patches:
  - namedscratchpads.
  - movestack.

manual code changes:
  - statusbar tags/ltsymbol colors, padding, highlight colors etc updated.
  - floating window centered by default (for scratchpads' sake).
  - monocle layout hides border (kinda hacky version).



terminal-games

aws_deploy

# RUSON
Command line json text parsing and processing utility. parsing json compliant with [`rfc8259`](https://datatracker.ietf.org/doc/html/rfc8259).
Benchmarked faster than [`jq`](https://stedolan.github.io/jq/) (more than _**twice**_ as fast).
_No third party dependencies_.

- [Installation](#installation)
  * [Requirements](#requirements)
  * [Build and Install](#build-and-install)
- [Usage](#usage)
- [Query Syntax](#query-syntax)
- [Examples](#examples)
- [Licence](#licence)

# INSTALLATION
### Requirements:
- [rust and cargo](https://www.rust-lang.org/)
- [GNU Make](https://www.gnu.org/software/make/)
- pkg-config (optional).
### Build and Install.
```sh
git clone --depth=1 https://github.com/lycuid/ruson.git
cd ruson
make && sudo make install
```
# USAGE
```txt
USAGE: ruson [FLAGS|OPTIONS]... FILE
Extract sub tree from valid 'json' text.
Use standard input, if FILE not provided.

FLAGS:
  -h, --help
                Display this help and exit.
  -v, --version
                Display version and exit.
  -p, --pretty
                Print pretty formatted 'json'.
  -t, --table
                Print table formatted 'json'.

OPTIONS:
  -q, --query <query>
                Query for extracting desired 'json' subtree.
```

# Query Syntax.
```sh
# Dot notation.
echo '{ "prop": "value" }' | ruson --query '.prop' # "value"

# Bracket notation.
echo '{ "prop": "value" }' | ruson --query '["prop"]' # "value"

# Array indexing.
echo '{ "prop": [1, 2, 3, 4, 5] }' | ruson --query '.prop[2]' # 3

# '.keys()' function (valid for 'object').
echo '{ "one": 1, "two": 2, "three": 3 }' | ruson -q '.keys()' # ["one", "two", "three"]

# '.values()' function (valid for 'object').
echo '{ "one": 1, "two": 2, "three": 3 }' | ruson -q '.values()' # [1, 2, 3]

# '.length()' function (valid for 'array' and 'string').
echo '[1, 2, 3]' | ruson -q '.length()' # 3

# '.map()' function (valid for 'array').
echo '{ "list": [{ "id": 1 }, { "id": 2 }, { "id": 3 }] }' | ruson -q'.list.map(.id)' # [1, 2, 3]
```

# EXAMPLES
Download latest _**xkcd**_ comic
```sh
curl https://xkcd.com/info.0.json 2>/dev/null | ruson -q ".img" | xargs wget
```
Pokemon attack names.
```sh
curl https://pokeapi.co/api/v2/pokemon/pikachu 2>/dev/null | ruson -q ".moves[0].move.name"
```

# LICENCE
[GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html)


Command line utility for parsing and processing JSON text (faster than 'jq').

ruson

chip8emu

OCaml's 99 problems: https://ocaml.org/learn/tutorials/99problems.html (...but in haskell). 


99problems

cluless statusbar
-----------------
A minialistic, lightweight, customizable statusbar (formerly *xdbar*), inspired by [xmobar](https://xmobar.org/) and [dwm](https://dwm.suckless.org/)'s statusbar, for X11 Desktops (wayland in progress), that are compatible with [EWMH](https://specifications.freedesktop.org/wm-spec/latest/) specifications.

Rendering styled/clickable text, is inspired by xmobar's approach of wrapping text in XML like *tags*.  
Populating statusbar is inspired by dwm statusbar's approach of using the root window's `WM_NAME` attribute text.

![dark.png](https://raw.githubusercontent.com/lycuid/assets/master/clubar/dark.png)

----

![light.png](https://raw.githubusercontent.com/lycuid/assets/master/clubar/light.png)

Description
-----------
```txt
  + - - - - - - - - - - - - - - - - - margin - - - - - - - - - - - - - - - - - +
  ¦ +------------------------------------------------------------------------+ ¦
  ¦ | + - - - - - - - - - - - - - - - padding - - - - - - - - - - - - - - -+ | ¦
  ¦ | ¦stdin                                                        WM_NAME¦ | ¦
  ¦ | +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | ¦
  ¦ +------------------------------------------------------------------------+ ¦
  +- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
```
- ***margin*** is the empty space outside of the bar window.
- ***padding*** is the space between the bar window edges and the drawing region.
- ***stdin*** text is typically provided by the window manager.
- ***WM_NAME*** (of the root window) can be set using the `xsetroot` command.

**Setting `WM_NAME`**
- [slstatus](https://tools.suckless.org/slstatus)
- [smolprog](https://github.com/lycuid/smolprog/) *(my personal script)*
- Custom script example:
```bash
#!/bin/bash
while true; do
  xsetroot -name "$(whoami)@$(hostname) on $(uname -o) | $(date)"
  sleep 1
done
```
Usage
-----
```txt
USAGE: clubar [OPTIONS]...
OPTIONS:
  -h, --help      print this help message.
  -v, --version   print version.
  -t, --topbar    window position (top/bottom edge of the screen).
  -c file, --config[=file]
                  filepath for runtime configs (supports: lua).
  -g values, --geometry[=values]
                  window geometry as 'x,y,width,height' (eg: '0,0,1280,720').
  -p values, --padding[=values]
                  window padding as 'left,right,top,bot' (eg: '0,0,10,10').
  -m values, --margin[=values]
                  window margin as 'left,right,top,bot' (eg: '0,0,10,10').
  -f color, --foreground[=color]
                  set default foreground color.
  -b color, --background[=color]
                  set default background color.
  --fonts[=values]
                  comma seperated fonts (eg: 'arial-10,monospace-10:bold').
SIGNALS:
  USR1: toggle window visibility (e.g. pkill -USR1 clubar).
```
Requirements
------------
  - ***free***, ***libre*** and ***open source*** Operating System (currently doesn't support \*BSD).
  - gnu make
  - libx11
  - libxft

**Optional**
  - pkg-config  (if not installed, update `config.mk` accordingly).
  - lua         (required if using `luaconfig` plugin).

Build
-----
**Default build**
```sh
make
```
**Build with plugins enabled**
```sh
make PLUGINS="luaconfig xrmconfig ..."
```
**Install**
```sh
sudo make install
```

**Available Plugins** 
(Note: plugins are just space seperated c filenames, from [plugins](/src/clubar/plugins/) directory, without file extension, see [examples](/examples).)

- **luaconfig**: runtime config support with lua source file.
- **xrmconfig**: runtime config support with X Resources.

Styling text
------------
**Template for styling text**
```text
<Tag:Mod1|Mod2|...|Modn=Value> Text </Tag>
```

| Tag     | Modifiers                 | Value       | Description                                       |
|---------|---------------------------|-------------|---------------------------------------------------|
| Fn      | -                         | Number      | Index of 'fonts' array from configs (default: 0)  |
| Fg      | -                         | Color       | Valid color name                                  |
| Bg      | -                         | Color       | Valid color name                                  |
| Box     | Left, Right, Top, Bottom  | Color:Size  | valid color name and size (default: 0) in pixels  |
| BtnL    | Shift, Ctrl, Super, Alt   | Command     | Raw command                                       |
| BtnM    | Shift, Ctrl, Super, Alt   | Command     | Raw command                                       |
| BtnR    | Shift, Ctrl, Super, Alt   | Command     | Raw command                                       |
| ScrlU   | Shift, Ctrl, Super, Alt   | Command     | Raw command                                       |
| ScrlD   | Shift, Ctrl, Super, Alt   | Command     | Raw command                                       |

Examples
--------
```xml
<Fn=1><Fg=#131313> Colored </Fg> text with <Bg=#c6c6c6> background</Bg></Fn>.
```
```xml
<Box:Bottom=#ffffff:1> underlined </Box> text.
<Box:Top|Bottom|Left|Right=#ffffff:1> Boxed in </Box> text.
```
```xml
<BtnL=systemctl reboot> reboot </BtnL>
<BtnL:Ctrl|Shift=sudo -A reboot now> reboot w/ confirmation </BtnL>
```
```xml
<ScrlU:Ctrl=amixer sset Master 5%+>
  <ScrlD:Ctrl=amixer sset Master 5%->
    volume
  </ScrlD>
</ScrlU>
```

Licence:
--------
[GPLv3](https://gnu.org/licenses/gpl.html)


A minialistic statusbar, inspired by xmobar and dwm's statusbar.

clubar

# smolprog
**S**ystem **M**ontitoring and **O**rdered **L**ogging **PROG**ram.

This is pretty much similar to another, very well known, open source project called [**`slstatus`**](https://tools.suckless.org/slstatus/).  
This program runs different procedures (***logger***) in seperate threads and outputs the values in an ordered manner to ***stdout***.  

## Use Case:
I personally use this to set the `WM_NAME` attribute of the root X11 window, which is then read and displayed by my statusbar: [xdbar](https://github.com/lycuid/xdbar/) (similar to [dwm's](https://dwm.suckless.org/) statusbar).  
Example:
```sh
src/main.scm | xargs -i xsetroot -name {}
```


Command line utility for system status monitoring.

smolprog

quick run: (simple string)
  $ runghc Main.hs '1,2,3,4'

quick run: (string with newline)
  $ runghc Main.hs $'1,2,3\n4'
  $ runghc Main.hs $'//;\n1;2;3\n4'

Using Cabal.
============
update and build first:
  $ cabal v2-update
  $ cabal v2-build

run with cabal:
  $ cabal v2-run stringcalc '1,2,3,4'
  $ cabal v2-run stringcalc $'//;\n1\n2\n3;4'

run tests: (includes dependencies, runs only with cabal)
  $ cabal v2-run tests


string-calculator

# cluless

**cluless** is a fantasy motivated, _(mildly opinionated)_ and customizable dynamic tiling [window manager](https://wiki.archlinux.org/title/window_manager). The development was motivated by the author's fantasy of having the feeling of being inside the [grid](https://tron.fandom.com/wiki/Grid), while using his computer. The design and structure was motivated by the author's previously, daily driven, window managers: [xmonad](https://xmonad.org) and [dwm](https://dwm.suckless.org).

![fancy](https://raw.githubusercontent.com/lycuid/assets/master/cluless/floating.png)
- Statusbar: clubar &lt;[https://github.com/lycuid/clubar](https://github.com/lycuid/clubar)&gt;
- Terminal: Simple Terminal &lt;[https://st.suckless.org/](https://st.suckless.org/)&gt;

Layouts
-------
|Tall (master/stack) | Full (fullscreen) |
|--------------------|-------------------|
|![tall](https://raw.githubusercontent.com/lycuid/assets/master/cluless/tall.png) | ![full](https://raw.githubusercontent.com/lycuid/assets/master/cluless/full.png) |

Requirements
------------
  - ***free***, ***libre*** and ***open source*** Operating System (currently doesn't support \*BSD).
  - gnu make
  - libx11
  - pkg-config (optional, changes would be required in Makefile)

Build and Install
-----------------
```sh
make && sudo make install
```

Usage
-----
put the following line in the `~/.xinitrc` file, and use any preferred method (e.g [startx](https://man.archlinux.org/man/startx.1), [xinit](https://man.archlinux.org/man/xinit.1)) to execute it.
```sh
exec cluless
```
Status logs for statusbar ([clubar](https://github.com/lycuid/clubar), in this case) are dumped to `stdout`, which can be redirected in any way suitable.
```sh
exec cluless | clubar
```
using fifo.
```sh
STATUS=/tmp/statusbar${DISPLAY}
[ ! -p ${STATUS} ] && mkfifo ${STATUS}

clubar <${STATUS} &
exec cluless >${STATUS}
```
using a fifo might be slower compared to other methods, but also can be very convenient as the statusbar program will run independent of the window manager (i.e statusbar can be killed, restarted etc. without killing the window manager process).

Features
--------
  - ***scratchpads***: togglable windows.
  - ***window rule***: hooks for newly created windows (make window floating, or move to different workspace etc).
  - ***companions***: window follows the user across workspaces. (best used with floating windows, as it might mess up the tiling).
  - ***magnify***: magnify focused window (useful in case of many tiled windows).

License:
--------
[GPLv3](https://gnu.org/licenses/gpl.html)


A fantasy motivated, customizable, dynamic tiling window manager.

cluless

assets

# Work in progress.

Requirements:
-------------
 - [sdl2](https://github.com/libsdl-org/SDL)
 - [SDL2_ttf](https://github.com/libsdl-org/SDL_ttf)
 - pkg-config (optional).

#### Build
```sh
make -j
```

#### Run
```sh
make -j run
```
