DEV Community: MoniqueLive

Integrating my AVR with Home Assistant

MoniqueLive — Mon, 30 Mar 2026 20:53:21 +0000

I was tired of digging through tiny on-device menus just to turn Zone 2 on and off on my AVR.

So I built a small Go CLI (zone2) that talks directly to the receiver over WebSocket, then wired it into Home Assistant as a command_line switch.

If you have an Arcam / AudioControl / JBL Synthesis receiver that exposes the setup WebSocket API on port 50001, this approach is straightforward and fast.

Source code

Why I chose a CLI first

Instead of jumping straight into a custom Home Assistant integration, I wanted a simple binary that:

can run anywhere
is easy to test from terminal
returns plain on / off output for automation parsing

That gave me a stable foundation before touching dashboards and YAML.

How the AVR communication works

The tool connects to:

ws://<AVR_IP>:50001

It sends binary protocol frames for Zone 2 (command 0x2F), then parses binary responses from the AVR.

Frame format (simplified):

request:  21 01 <command> <len> <payload...> 0D
response: 21 01 <command> <status> <len> <payload...> 0D

For reads, it queries the Zone 2 model and inspects the second byte (model[1]) as power state:

0 => off
1 => on

For writes (on, off, toggle), it updates that byte and sends the full model back.

Reliability changes that mattered

The hard part was not "sending commands", it was making behavior reliable enough for automations.

I added a few guardrails:

Frame splitting
- Receivers can send multiple protocol frames in a single WebSocket message.
- The client extracts valid frames by header/length/terminator and picks the right command.
Strict response parsing
- Validates framing, command ID, terminator, and declared payload length.
- Rejects malformed frames early.
Retry on transient states
- Zone 2 query retries up to 5 times.
- Handles temporary 0x85 status by waiting briefly and retrying.
Post-write verification loop
- After a write, it re-queries state until the target sticks (default 20 attempts).
- This avoids false positives where a write ACK arrives but state does not actually change.

This is what made it usable from Home Assistant without random "it worked... I think?" moments.

CLI usage

./zone2-macos-arm64 -host YOUR_AVR_IP -mode status
./zone2-macos-arm64 -host YOUR_AVR_IP -mode on
./zone2-macos-arm64 -host YOUR_AVR_IP -mode off
./zone2-macos-arm64 -host YOUR_AVR_IP -mode toggle

Flags:

-host (required)
-mode (on|off|toggle|status)
-timeout (default 4s)
-verify (default 20, used for writes)
-verbose (prints raw TX/RX frames)

Home Assistant integration

I cross-compile a Linux ARM64 binary for HA OS (Raspberry Pi 5), copy it into /config/bin, and expose it via command_line:

command_line:
  - switch:
      name: AVR Zone 2
      unique_id: avr_zone2
      command_on: "/config/bin/zone2 -host YOUR_AVR_IP -mode on -timeout 4s -verify 20"
      command_off: "/config/bin/zone2 -host YOUR_AVR_IP -mode off -timeout 4s -verify 20"
      command_state: "/config/bin/zone2 -host YOUR_AVR_IP -mode status -timeout 4s"
      value_template: "{{ value | trim | lower == 'on' }}"
      scan_interval: 10

Because the CLI prints exactly on or off, the value template stays simple and reliable.

Build + release flow

The repo includes:

Makefile targets for Linux ARM64 + macOS binaries
CI (go test, go vet)
tag-triggered GitHub release workflow attaching compiled binaries

That made it easy to test locally and deploy repeatably.

Final thoughts

This was a small project, but a useful reminder: in home automation, state verification is more important than "command sent successfully".

A tiny, deterministic CLI with clear output is often enough to bridge unsupported hardware into Home Assistant cleanly.

If I extend this next, I'll likely add controls for input/volume and package a full HA integration once the protocol surface is mature.

Tech Meets Tunes: Creating a Seamless Alfred Workflow for EDM Aficionados

MoniqueLive — Fri, 05 Jan 2024 18:54:46 +0000

The Problem

If you're a EDM fan like me you probably know the super traditional website Digitally Imported.

I'm a long time supporter (and I recommend you consider supporting it - streaming bills ain't cheap ya know). But one thing bugged me for a long time: it has no native player like Spotify and Apple Music. And I like changing stations all day long. And I don't like keeping a browser tab exclusively for this.

Since I'm a heavy Alfred user I looked for a workflow but had no luck. So I made one.

The Solution

The workflow editor is pretty neat. You drop boxes and link them in order to make one box's output become the other's input:

My Alfred's Workflow panel

And that's it. Just two boxes linked in order to play some electronic music ❤️

But wait, there's more!

It would be a very boring article if it ended here, right? 😊
First of all, the list of radio stations is huge! (99):

double clicking on List Filter

I would never type 99 times each station information... No... I asked our friendly overlord GPT-4 for some help.

Chat GPT to the rescue

All I had was the 99 url slugs for each radio station. When you open a playlist (.pls file) you'll get all the streaming url's in the form:

http://prem1.di.fm/${query}?XXXXXX

Where ${query} is the station name and XXXX is your 'Listen key' that can be grabbed on the Settings page.

But in order to fill the workflow's List Filter I needed a .csv file with 3 columns:

First some words, separated by space, which are searched after you type your workflow's keyword
A plain text english description that will be shown as a subtitle
The value that will be passed as the input for the next node on the graph

So the prompt I wrote was basically:

Given the following slugs:

- 00sclubhits
- ambient
- atmosphericbreaks
... (until 99)

Create a three column CSV formatted list of:

- the slug broken in words
- a plain english description of the slug
- the slug unchanged

For example:

- 00sclubhits

in CSV:

00s club hits, 2000's Club Hits, 00sclubhits

And it very kindly generated this csv file. ❤️ (full disclosure: I removed the header line and removed extra spaces between columns that confused Alfred)

Then I dragged the generated .csv file into the left column of the List Filter and that was it for this node.

The second node is super simple. It's a Run Script node with the following:

Open Apple Music with the following url

You can use your preferred player here. I tested with VLC and Apple Music.

And that's it!

Now you have a personalized station picker:

All the vocal stations

I hope you enjoyed reading this as much as I enjoyed putting this together.

Have a good one!

Using fzf to choose from a list of choices

MoniqueLive — Wed, 06 Sep 2023 20:18:53 +0000

Some scenarios I use fzf to help me pick from a list of choices

#1 - picking which docker images I'd like to remove

fzfrmimage () {
  # - list all docker images, skipping the first line
  # - feed these lines into fzf (user: TAB select/hit ENTER)
  # - format a list of 'image:tag's and pass it to `docker image rm` 
  images=$(docker image ls | tail -n +2 | fzf | sed -n 's/\(\S*\) *\(\S*\).*/\1:\2/p')
  docker image rm $(echo $images)
}

#2 - picking from pygments themes (styles)

I used this as a oneliner (actually 2 for better legibility) in order to preview some sample code using the style.

pygmentize -L styles | sed -n 's/^* \(.*\):/\1/p' |\
  fzf --preview "pygmentize -P style={} -l python ~/prj/python/bored/main.py"

list all styles
filter for lines that start with an asterisk
remove the trailing ':' character
feed the list into fzf with a sample code preview
user: TAB select / hit ENTER
fzf prints the selected themes
profit!

FZF is a super flexible tool that I'm always looking for ways to leveraging its powers. Thanks Junegunn Choi for creating it!

Using nerd font symbols and emoji with any (unpatched) font in Linux

MoniqueLive — Tue, 27 Jun 2023 23:29:05 +0000

After I read the note on this question on the Kitty terminal FAQ I started paying attention to editors, ide's and terminals that support fallback fonts.

A fallback font is a reserve typeface containing symbols for as many Unicode characters as possible. When a display system encounters a character that is not part of the repertoire of any of the other available fonts, a symbol from a fallback font is used instead. Typically, a fallback font will contain symbols representative of the various types of Unicode characters. ¹

But not all editors, ide's or terminals support them. Like the terminal emulator alacritty for example.

But Linux's fontconfig package is very complete and it allows you to create font families, which I understood are virtual fonts you create in order to have the fallback mechanism manually set up.

So let's cut to the chase! First create a file in ~/.config/fontconfig called fonts.conf with the following contents:

<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
<fontconfig>
  <match target="font">
    <edit name="autohint" mode="assign">
      <bool>true</bool>
    </edit>
  </match>
  <alias>
    <family>my-chosen-font-family</family>
    <prefer>
      <family>JetBrains Mono</family>
      <family>Symbols Nerd Font</family>
      <family>Noto Color Emoji</family>
    </prefer>
  </alias>
</fontconfig>

The <match> tag asks for auto-hinting in order to have better looking fonts.

The <alias> tag contains the name of your virtual font my-chosen-font-family and the set of fonts that belong to it. In my case I have an unpatched (original) font, the symbols nerd font and the emoji one.

Now all you have to do is configure your apps to use it. In alacritty it would be:

font:
  normal:
    family: my-chosen-font-family
    style: Regular

  bold:
    family: my-chosen-font-family
    style: Bold

  italic:
    family: my-chosen-font-family
    style: Italic

  bold_italic:
    family: my-chosen-font-family
    style: Bold Italic

Enjoy!

https://en.wikipedia.org/wiki/Fallback_font ↩

Passing multiple arguments to golang sub-templates

MoniqueLive — Mon, 28 Nov 2022 21:04:31 +0000

Have you ever wanted to pass multiple arguments to a go sub-template? If you google it you'll be convinced it's not possible. But bear with me.

In go templates you can pass a single "argument" (pipeline in go parlance) to a "sub-template" defined block. But by creating a simple helper function you can pass as many arguments as you want. Simply add this function to your FuncMap:

func(els ...any) []any {
    return els
}

And you'll be able to create constructs such as:

{{ template "MyTemplate" (arr "first" 123 .Some.Value) }}
{{ template "MyTemplate" (arr "second" 456 .Other.Value) }}

{{ define "MyTeplate" }}
  {{ $strArg := index . 0 }}
  {{ $intArg := index . 1 }}
  {{ $valArg := index . 2 }}

  This is my str {{ $strArg }} parameter.
  ...
{{ end }}

I named arr my helper func, but you can call it whatever you want.

Enjoy!

Auto activate and deactivate python venv using zsh (and fish)

MoniqueLive — Fri, 17 Dec 2021 15:01:10 +0000

When I found out about python venv (apt-get install python3-venv) I became an instant addict. It's clean, it's built-in and it's explicit.

Now every time I create a new project folder I automatically run python3 -mvenv venv && source ./venv/bin/activate.

But typing ./venv/bin/activate and then deactivate is too much work for my lazy programmer head.

So I decided to finally invest 10 minutes to free me from activating and deactivating python's env every time I enter or leave a folder with my standard ./venv folder:

#---------------------------------------------- chpwd pyvenv ---
python_venv() {
  MYVENV=./venv
  # when you cd into a folder that contains $MYVENV
  [[ -d $MYVENV ]] && source $MYVENV/bin/activate > /dev/null 2>&1
  # when you cd into a folder that doesn't
  [[ ! -d $MYVENV ]] && deactivate > /dev/null 2>&1
}
autoload -U add-zsh-hook
add-zsh-hook chpwd python_venv

python_venv

edit: just figured out that deactivating was working because of other stuff installed in my shell. Now it's a bit more agressive but works 100%

edit2: been trying out fish shell. Here it is translated to fish script:

function python_venv --on-variable PWD
    set myvenv ./venv
    if test -d $myvenv
        source $myvenv/bin/activate.fish
    else if type -q deactivate
        deactivate
    end
end

Python3 + GTK+3 + Glade + Templates = <3

MoniqueLive — Sun, 28 Mar 2021 01:26:28 +0000

Many software that you use on your Gnome environment could've been developed with Python. Apps like Gnome Music and Gnome Tweaks are some examples.

In this article I'll show you a minimal example in order to give you a foundation for your ideas. Let's go:

Create a basic layout on Glade:

Stuff you need to pay attention to:

The top level component is a GtkApplicationWindow (you can find it under Toplevels button)
While it's selected, check the Composite checkbox on the farther right (super important!)
When you check the Composite checkbox the ID field becomes Class Name. Give it a name and save it, we'll use it soon
Give the button an ID and save it, we'll use it soon

With the Button selected, switch to the Signals tab:

Click on the Handler column on the clicked Signal row
Type the first letter of your button's name
Accept the suggestion (btnMain_clicked_cb, in my example) and save it, we'll use it soon

And that's it for Glade. Save your .glade file on your project dir.

Create a basic Python skeleton:



import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gio, Gtk

import sys


#
# 1. our .glade file (may contain paths)
#
@Gtk.Template.from_file("a.glade")
class AppWindow(Gtk.ApplicationWindow):
    #
    # 2. the GtkApplicationWindow class
    #
    __gtype_name__ = "app_window"

    #
    # 3. the Button name we saved above
    #
    btnMain: Gtk.Button = Gtk.Template.Child()

    #
    # 4. the signal handler name we saved above
    #
    @Gtk.Template.Callback()
    def btnMain_clicked_cb(self, widget, **_kwargs):
        assert self.btnMain == widget
        print(widget.get_label())


class Application(Gtk.Application):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, application_id="dev.monique.Gtk1",
                         flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs)
        self.window = None

    def do_activate(self):
        self.window = self.window or AppWindow(application=self)
        self.window.present()


if __name__ == '__main__':
    Application().run(sys.argv)

You'll also need to:



pip install PyGObject

It may complain about missing libraries, just read the error output and install the missing dependencies (I had to apt install libcairo2-dev libgirepository1.0-dev)

With this code you'll be able to get started.

Good luck!

How I compile OpenCV on Linux with lots of bells and whistles (CuDNN, CUDA, OpenGL, Qt, TrueType, Video CODECs)

MoniqueLive — Tue, 16 Feb 2021 02:09:32 +0000

Em português.

OpenCV is a beast of a library. It's huge. But it's also super flexible. You typically choose what your binary will contain by providing optional dependencies but sometimes you have to nudge it to the direction you need.

In this guide I'll show you how I compile it with the longest cmake line you'll ever see (hopefully) and I'll also add comments so you know what you need to compile it successfully.

Let's get started.

Downloading

You need two projects in order to build OpenCV: the OpenCV source code and OpenCV contrib.

You can either download the latest versions as as zip/tar ball or you can clone them and checkout the version (aka tag) you need.

Whatever way you choose, for the purpose of this tutorial all you need is both projects to be sitting next to each other on the same folder:

Dependencies

If you install all the depencies I explain bellow you'll have:

--   OpenCV modules:
--     To be built:                 aruco bgsegm bioinspired calib3d ccalib core cudaarithm cudabgsegm cudacodec cudafeatures2d cudafilters cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping cudev cvv datasets dnn dnn_objdetect dnn_superres dpm face features2d flann freetype fuzzy gapi hfs highgui img_hash imgcodecs imgproc intensity_transform line_descriptor mcc ml objdetect optflow phase_unwrapping photo plot python3 quality rapid reg rgbd saliency shape stereo stitching structured_light superres surface_matching text tracking video videoio videostab xfeatures2d ximgproc xobjdetect xphoto
--     Disabled:                    world
--     Disabled by dependency:      -
--     Unavailable:                 alphamat cnn_3dobj hdf java julia matlab ovis python2 sfm ts viz

This is what you'll need:

python3 + numpy - I generally install it globally, outside of any venv/virtualenv sandboxes. Having OpenCV installed globally I can reference it on the venv sandboxes when needed. You'll see a similar cmake output:
python3-pyqt5.qtopengl - it's enough to bring in the dependencies in order to detect Qt + OpenGL. Why is OpenGL so important, you may ask? Hardware accelerated frame rates. You'll see a similar cmake output:
ffmpeg + gstreamer - if you want to load different video encodings:
libfreetype-dev + libharfbuzz-dev - if you want support for truetype fonts
CUDA + CuDNN - this one deserves a more detailed explanation bellow.

CUDA + CuDNN

CUDA (and CuDNN) are usually installed under the same directory. And this directory is typically /usr/local/cuda-<version>. But this is not a rule. I use PopOS and it gets installed in /usr/lib/cuda-<version>. It can also have as many versions as you want installed in parallel:

As you can see above, even though CUDA-11.2 was installed automatically (it's the current version as of today), CuDNN is only available up until 11.1 so I was forced to install CUDA-11.1 as well in order to have both CUDA and CuDNN installed on the same tree structure.

In order for cmake to find CUDA and CuDNN all you need is add <your CUDA root>/bin to your path.

You can check like this:

Super easy right? 🤣

Let's build it then!

Check for dependencies

In order to compile you need to create a build folder inside your opencv library root folder (cd opencv; mkdir build; cd build).

Now take a deep breath and enjoy the largest command line I've ever written for a single command:

cmake -D CMAKE_CXX_COMPILER=/usr/bin/g++ \
-D CUDA_HOST_COMPILER:FILEPATH=/usr/bin/gcc-9 \
-D CUDA_NVCC_FLAGS=--expt-relaxed-constexpr \
-D WITH_CUDA=ON \
-D WITH_CUDNN=ON \
-D CUDNN_INCLUDE_DIR=/usr/lib/cuda-11.1/include \
-D OPENCV_DNN_CUDA=ON \
-D ENABLE_FAST_MATH=1 \
-D CUDA_FAST_MATH=1 \
-D CUDA_ARCH_BIN=8.6 \
-D WITH_CUBLAS=1 \
-D WITH_TBB=ON \
-D WITH_OPENMP=ON \
-D WITH_IPP=ON \
-D CMAKE_BUILD_TYPE=RELEASE \
-D WITH_CSTRIPES=ON \
-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
-D CMAKE_INSTALL_PREFIX=/usr/local/ \
-D WITH_QT=ON \
-D WITH_OPENGL=ON \
-D BUILD_EXAMPLES=OFF \
-D BUILD_DOCS=OFF \
-D BUILD_PERF_TESTS=OFF \
-D BUILD_TESTS=OFF \
-D BUILD_opencv_python3=ON \
-D PYTHON3_EXECUTABLE=$(which python3) \
-D PYTHON_INCLUDE_DIR=$(python2 -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())") \
-D PYTHON3_INCLUDE_DIR=$(python3 -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())") \
-D PYTHON3_LIBRARY=$(python3 -c "from distutils.sysconfig import get_config_var;from os.path import dirname,join ; print(join(dirname(get_config_var('LIBPC')),get_config_var('LDLIBRARY')))") \
-D PYTHON3_NUMPY_INCLUDE_DIRS=$(python3 -c "import numpy; print(numpy.get_include())") \
-D PYTHON3_PACKAGES_PATH=$(python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())") \
..

Don't miss the double dots at the end!

Some configurations worth explaining:

CMAKE_CXX_COMPILER - to compile c++ files
CUDA_HOST_COMPILER:FILEPATH - to compile cuda files - During system76-cudnn package installation I noticed it installed gcc-9. Very deterministic (not), I know.
CUDA_NVCC_FLAGS - needed some day, may remove eventually
CUDNN_INCLUDE_DIR - check your cuda home folder
CUDA_ARCH_BIN - the architecture of your GPU. Check it here https://developer.nvidia.com/cuda-gpus
OPENCV_EXTRA_MODULES_PATH - relative or absolute path to opencv_contrib folder

In order to validate if all your dependencies are ok, read the line Unavailable: ... in the beginning of the previous section and check for differences with yours.

If you need to rerun cmake, leave the build folder, destroy it, recreate it, change back to it, only then rerun cmake... It's a tedious process but there's no shortcut here unfortunately.

Compiling

This step is the easiest. Given all the dependencies are met all you have to do is run the make command:

make -j<number of processes>

I highly recommend using the -j flag in order to cut compilation time. If you want to keep using your machine while the compilation is running, I recommend using $(nproc)-2.

For your reference, using -j60 + nvme, the compilation process takes 5m30s here.

If anything goes wrong don't be afraid to scroll up (or search for error:) and check what happened.

Installing

If everything went fine and dandy:

💯% baby!

All you need to do is:

sudo make install

That's the only time you need to invoke root's super powers in order to write files on /usr/local.

Validating

To test your achievement:

$ python3
>>> import cv2
>>> print(cv2.getBuildInformation())

You should see the same output as cmake's.

Using

In order to use OpenCV with a venv (you can read more about venv here) use the flags:

python -mvenv --system-site-packages venv

This will create a sub-folder named venv with a sandbox that comes with "system wide packages", such as ... you know it.

Closing

If you read until here, congrats, you are a very determined person 🤣

If you need any help just leave a comment!

Good luck.

Pre-compiled pytorch versions

MoniqueLive — Wed, 20 Jan 2021 17:51:25 +0000

I had just found about a repository that just saved my bacon so I decided to share it with you guys.

If you go to pytorch's website, you'll be given a lot of choices to install it:

The thing is, if you want to install a different version than the one listed (1.7.1 as of today) you'll begin a not very pleasant treasure hunt.

There's a repo that somehow took me quite a while to find here:

https://download.pytorch.org/whl/torch_stable.html

But you don't need to click on it! You can ask pip to fetch it for you:

pip[3] install pytorch==1.6.0+cu101 -f https://download.pytorch.org/whl/torch_stable.html

And voilá, your package will be installed automagically!

Now some extra tips:

Some cuda versions are considered "default". For instance if you look for 1.6.0+cu102 you won't find it, that's because installing pip install cuda==1.6.0 will automatically fetch cuda's 10.2 version.
If you're a masochist and need the CPU-only version: pip install 1.6.0+cpu
To save this repo on your requirements.txt, just add this as the first line of it:

-f https://download.pytorch.org/whl/torch_stable.html

...
torch==1.6.0+cu110
...

Happy torching!

Autocompletion globally installed OpenCV with PyCharm

MoniqueLive — Mon, 28 Dec 2020 17:19:43 +0000

Intro

For a long time I was a user of the virtualenv module. But ever since I learned about the standard module venv I became a devotee.

For starters it comes bundled with python (or by installing the python3-venv package). It's also more predictable than virtualenv since you don't need to mess with your .{bash/zsh/fish}rc files and it's generally installed under your project's root dir.

But there's one exception for using locally installed packages, and it's packages that need to be built on your machine. OpenCV is one of them. You can install a pre-built one using pip install opencv-python-contrib but it won't take advantage of your shiny new GPU.

OpenCV

Building OpenCV is a whole topic on itself but assuming you did all the steps (cmake + infinite flags / sudo make install) it'll be installed on your machine globally (on /usr/lib).

To use it locally on a venv isolated environment, you have to use the following flag:

python -mvenv --system-site-packages venv

The --system-site-packages flag creates a local environment but includes all the globally installed modules.

Just for completion sake, don't forget to active the environment:

source venv/bin/activate

PyCharm

Now if you use PyCharm and would love to see the autocompletion work with your just installed OpenCV there's one extra step.

First of all, tell PyCharm to use your venv by going to Settings -> Python Interpreter -> "cog" button -> Add -> Existing environment.

(If you create your venv first and then open the directory on PyCharm, it'll autodetect it)

But by default PyCharm won't find the .so built for OpenCV. You have to tell it where it is.

To find where yours was installed you can use the find tool:

find /usr -name cv2\*so

Mine was found under /usr/lib/python3/dist-packages/cv2/python-3.8/cv2.cpython-38-x86_64-linux-gnu.so

Now you get back to the interpreter settings (Settings -> Python Interpreter -> "cog" button -> Show all), select the interpreter for your project, click on the toolbar's last button (Show paths for the selected interpreter) and add the above directory removing your *.so file name:

After this last extra step autocomplete should work like a charm (oops...).

Happy coding!

OBS Studio as a Virtual Webcam

MoniqueLive — Tue, 22 Dec 2020 17:18:35 +0000

In the year 2020 video conferencing exploded worldwide. It became a necessity for many (now) remote workers.

If you happen to be a lucky (debian-based) Linux user, this set of steps will show you how to use OBS Studio as a video source in any conferencing software (Google Meet, Zoom.us, Discord, etc.). Here we go:

Install OBS, libOBS, v4l loopback, qt-dev

sudo apt-get install obs-studio libobs-dev v4l2loopback-dkms qtbase5-dev

Configure the kernel module (v4l2loopback)

sudo touch /etc/modules-load.d/v4l2loopback.conf
sudo echo v4l2loopback > /etc/modules-load.d/v4l2loopback.conf
sudo echo 'options v4l2loopback card_label="OBS Video Source" video_nr=10 exclusive_caps=1' > /etc/modprobe.d/v4l2-obs-studio.conf
sudo depmod -a
sudo modprobe v4l2loopback

Parameters:

video_nr device number that will be created /dev/video10
card_label camera name that will show up on Meet/Zoom/Discord/etc
exclusive_caps to work with Google Chrome

Install the OBS plugin (v4l2sink)

git clone --recursive https://github.com/obsproject/obs-studio.git # OBS
git clone git@github.com:CatxFish/obs-v4l2sink.git # Plugin

cd obs-v4l2sink
mkdir build ; cd build
cmake -DLIBOBS_INCLUDE_DIR="../../obs-studio/libobs" -DCMAKE_INSTALL_PREFIX=/usr ..
make -j
sudo make install

(edit: I just found out how to install plugins on your home dir instead of messing around your system's filesystem)

It'll be installed in /usr/lib/obs-plugins, but let's install it on our home directory:

mkdir -p ~/.config/obs-studio/plugins/v4l2sink/{data,bin/64bit}
ln -sf /usr/lib/obs-plugins/v4l2sink.so ~/.config/obs-studio/plugins/v4l2sink/bin/64bit/
ln -sf /usr/share/obs-plugins/v4l2sink/locale ~/.config/obs-studio/plugins/v4l2sink/data/

If all worked, on the Tools menu there'll be an item V4L2 Video Output.
Set the device to /dev/video10, the video format to YUY2. Click on Auto-Start, Start and create a scene...

Happy conferencing!

Haskell LSP (bonus: for Vim)

MoniqueLive — Tue, 27 Oct 2020 01:04:56 +0000

So you enjoy coding in Haskell. And you heard kids nowadays code using this LSP thingy.

Let's cut to the chase: LSP is a spec that standardizes auto-completion, code navigation, linting, and all good stuff usually found in modern IDE's. In order to use LSP with your favorite language you'll need a language server to communicate with your editor of choice.

In this article we'll focus on haskell's language server. Not long ago the language server of choice used to be hie but now it's deprecated.

So let's get started! Assuming you have Haskell Stack up and running:

$ stack install ghcid hspec-discover # optional but great
$ git clone https://github.com/haskell/haskell-language-server --recurse-submodules
$ cd haskell-language-server
$ stack ./install.hs help
$ stack ./install.hs hls

The binaries we'll be at the usual place: ~/.local/bin

Right, but how do I use it? Well it depends on your editor. Let me show you how I do it in my .vimrc:

Plug 'prabirshrestha/vim-lsp'
Plug 'prabirshrestha/asyncomplete.vim'
Plug 'prabirshrestha/asyncomplete-lsp.vim'
Plug 'mattn/vim-lsp-settings'

Please read their documentation!

" vim-lsp-settings won't detect hls automatically as of today (2020-10-26). Let's teach it:
if (executable('haskell-language-server-wrapper'))
  au User lsp_setup call lsp#register_server({
      \ 'name': 'haskell-language-server-wrapper',
      \ 'cmd': {server_info->['haskell-language-server-wrapper', '--lsp']},
      \ 'whitelist': ['haskell'],
      \ })
endif

" My Mappings
function! s:on_lsp_buffer_enabled() abort
    setlocal omnifunc=lsp#complete
    setlocal signcolumn=yes
    if exists('+tagfunc') | setlocal tagfunc=lsp#tagfunc | endif
    nmap <buffer> gd <plug>(lsp-definition)
    nmap <buffer> gr <plug>(lsp-references)
    nmap <buffer> gf <plug>(lsp-code-action)
    nmap <buffer> gi <plug>(lsp-implementation)
    nmap <buffer> gt <plug>(lsp-type-definition)
    nmap <buffer> <F2> <plug>(lsp-rename)
    nmap <buffer> [g <Plug>(lsp-previous-diagnostic)
    nmap <buffer> ]g <Plug>(lsp-next-diagnostic)
    nmap <buffer> K <plug>(lsp-hover)
    xmap <buffer> f <plug>(lsp-document-range-format)
    nmap <buffer> <F5> <plug>(lsp-code-lens)

    " buffer format on save
    " autocmd BufWritePre <buffer> LspDocumentFormatSync
endfunction

" Decorations
augroup lsp_install
    au!
    let g:lsp_signs_enabled = 1         " enable signs
    let g:lsp_diagnostics_echo_cursor = 1 " enable echo under cursor when in normal mode
    let g:lsp_signs_error = {'text': '✗'}
    " let g:lsp_signs_warning = {'text': '‼', 'icon': '/path/to/some/icon'} " icons require GUI
    " let g:lsp_signs_hint = {'icon': '/path/to/some/other/icon'} " icons require GUI
    let g:lsp_signs_warning = {'text': '‼'}
    let g:lsp_highlight_references_enabled = 1
    highlight link LspErrorText GruvboxRedSign " requires gruvbox
    highlight clear LspWarningLine
    " highlight lspReference ctermfg=red guifg=red ctermbg=green guibg=green
    highlight lspReference guibg=#303010

    " call s:on_lsp_buffer_enabled only for languages that has the server registered.
    autocmd User lsp_buffer_enabled call s:on_lsp_buffer_enabled()
augroup END

The first time you start vim with a Haskell file it'll take a while (you can check vim-lsp's status with :LspStatus). As soon as a left margin (1 character wide) shows up, you're good to go!

Now your Vim is an LSP powerhouse:

Hover:

Auto-complete:

etc. etc. etc.

Enjoy!