The last time I seriously tried to run Linux as my daily I was in high school. Due to gaming (Asheron’s Call), it wasn’t long before I was back on Windows. That experience gave me just enough exposure to the basics and get comfy on the command line, but not long enough to fully grok all the bits and pieces that make up the Linux ecosystem. I present that background to give some understanding of the mindset I took into Omarchy as I departed from macOS.

Despite the rather gross looking set up with a wire dangling across my keyboard, I’m still enjoying my time on Omarchy. More specifically, my time with Hyprland on Arch. Omarchy has been a beautiful, approachable bridge to Linux land. Without it, I’m certain I’d still be trapped in the walled garden and complaining about it. I was always aware (though recently more clearly) that most of the “Omarchy” experience is just a tasteful combination of existing software with usable defaults. It’s awesome and I’m grateful for it’s existence.

As I spend more time with Omarchy, it’s inevitable that I’ll peel back the layers and begin to understand how it all fits together. Instead of constantly talking about “Omarchy”, I can talk about the actual piece of software itself. Which leads me to….

Hyprland

Described as a “Modern compositor with the looks”, it’s a dynamic, fast, lightweight tiling Wayland compositor with smooth animations and as advertised…“the looks.” It’s a vast ecosystem of “hypr*” things like Hypridle, Hyprlock, Hyprsunset, Hyprpaper and on and on. In my opinion, this is ecosystem is responsible for most of the appeal of Omarchy.

Hyprland itself is less than 4 years old and, as far as I can tell, mostly built by one person Vaxry. He’s an unusual (or completely usual depending on your circle) fellow and his leadership is definitely felt. Here’s an example from the official Hyprland X account:

It’s an insane accomplishment and really impressive. For better or worse, there are times where his leadership is more obvious than usual. Take for example this lovely specimen:

Don’t take this as a complaint. Personally, I like the existence of this sort of thing as it’s a strong indicator that corporate money and influence has yet to infiltrate this awesome project. But, it’s worth being warned about. Especially for those coming from macOS.

Future

At this point, I fully expect some day in the future to venture off the Omarchy highway and into my own custom Hyprland/Arch config. Especially as I learn more about all the awesome/crazy stuff Omarchy left out of Hyprland (see Hall of Fame). But, until that day arrives, I’ll be riding happy on Omarchy.

Omarchy enters the chat

I had been hearing about Omarchy all over my X feed. Finally I watched a video put out by DHH about version 2.0, and that was enough for me. I dropped $2,200 on a Framework 13 with the AMD Ryzen AI 9 HX 370, ordered it, and a week later it was in my hands. There was no official Omarchy ISO yet, so I installed vanilla Arch and ran the install script. I had already ordered the magic WJESOG DisplayPort to USB-C cable^Poop that DHH said actually makes Apple and LG 5K displays behave on Linux. I plugged my LG UltraFine 5K into the Framework and… it just worked. Hyprland felt snappier than anything I’d used in years. I was in love.

For three awesome weeks

One morning the monitor was black. No signal. Classic Linux adventure time. A lot of Google, a lot of AI chats, and eventually I discovered the fix was in a newer kernel than the one Omarchy was shipping. Updated the kernel, monitor came back. Life was good again.

Then Omarchy 3.0 dropped. I upgraded. Something in the migrations broke and global shortcuts stopped launching anything. Dug through GitHub issues, manually patched a few config files, and got it working again. But now I had that nagging feeling you get with any big upgrade path: cruft. Now that Omarchy 3.1.0 finally shipped with a proper ISO, I decided to nuke it and start clean.

The fresh install took literally two minutes. I rebooted, grinning at how buttery smooth everything felt… and the LG was dead again. Same symptoms. Updated the kernel…still dead. This time the fix was a Framework BIOS update that the excellent people in the Omarchy Discord walked me through. Monitor sprang back to life. High-fives all around.

The very next morning? Black screen again.

At this point the Discord went quiet, and so did I. I’ve run out of google-fu. When everything is working, Omarchy (really Hyprland plus the mountain of thoughtful defaults) is the best desktop experience I’ve ever had. But I’m tired of waking up to a coin flip on whether my $2,000 laptop will acknowledge its $1,200 monitor.

Final Verdict

Omarchy is magical when it’s happy. The problem is it’s moody, and right now my LG 5K and Framework combo is stuck in an unhappy phase that neither I nor the community has solved. I haven’t quite given up yet, but I fear I’m days away from returning to macOS with a slightly defeated sigh.

Linux on the desktop is still an adventure. Sometimes that’s fun. Sometimes you just want your monitor to work.

Update 2025-11-21

After spending way too much time on this, I appear to be having success by moving the DisplayPort and USB-A expansion cards to the nearer ports. This required putting the USB-A on one side and the DisplayPort on the other. That means I currently have a fun little wire hanging across the Framework 13’s keyboard.

I am only getting 3840x2160 on a 5K monitor, but at least it has been reliable so far. And yes, this is a worse set up than my sleak M4 PRO with a single Thunderbolt cable that provides not only monitor, keyboard, & webcam, but also power. However, Omarchy is so much better for me than macOS that it’s absolutely worth it.

I read the book straight through without touching a keyboard. The concepts were well explained and easy to understand. With the book read, I decided to start an app to play with.

the ash installer

The Ash site has a cool “installer” that let’s you enter a name, select some options, and generate a single command to get up and running.

I went with the default options except I added Password auth.

Running this command created a new Phoenix app called Rails, used igniter to install Ash & the other selected/required libraries, set up the initial database, and ran the migrations.

We now have an app we can start adding resources to. However, I was mostly curious how the auth stuff was implemented.

the login form

By default Ash handles the rendering of the account-related forms for registering, logging in, etc. These work well enough for an internal app, but will need to be customized for a real app. Let’s try to customize the login form and see how it goes.

customizing ash’s login form

You can customize AshAuthentication Phoenix’s (APP) forms using overrides. The Rails app comes with all this wired up and we can start overriding in lib\rails_web\auth_overrides.ex.

APP has the concept of a Banner that appears above the sign-in form. Here we customize it to hide the image, make the text larger, and change it to “Let’s sign in!”.

defmodule RailsWeb.AuthOverrides do
  use AshAuthentication.Phoenix.Overrides

  override AshAuthentication.Phoenix.Components.Banner do
    set :image_url, nil
    set :text_class, "text-xl"
    set :text, "Let's sign in!"
  end
end

Pretty sweet!

However, we’ve also hit the first example of not being on the happy path. We want to customize the banner text on each page. Sign-in should say “Sign in to Rails”, password reset should say “Reset your password”, and so on. Turns out, that’s not really possible. APP uses one Banner component across all authentication pages. The component doesn’t know which page it’s on. It just renders the same text everywhere.

My first thought it to make the Banner component smart. Maybe it could detect the current URI and show different text based on the page. Nope, it won’t work. The Banner component doesn’t have access to the current URI. The override system doesn’t pass that information down.

As a workaround, we can creat separate Banner override modules for each authentication route. Each module sets its own text. Then we configured the router to use the right override for each route:

scope "/", RailsWeb do
    ...
    sign_in_route register_path: "/register",
      overrides: [RailsWeb.AuthOverrides.SignInBanner]
      ...

    reset_route auth_routes_prefix: "/auth",
      overrides: [RailsWeb.AuthOverrides.ResetBanner]
      ...

    confirm_route Rails.Accounts.User, :confirm_new_user,
      overrides: [RailsWeb.AuthOverrides.ConfirmBanner]
      ...
    ...
 end

Pretty sweet!

But we’ve hit another snag! Sign-in and register forms share the same route in APP. They use the register_path option to handle both forms on one route. So we can’t have different banner text for sign-in vs register. They have to share.

I couldn’t find a good way around this without implementing fully custom forms. For now, we have to compromise with “Welcome to Rails”. It works for both new and returning users.

final thoughts

You get a lot out of the box and it really has that Ruby on Rails feel. My fear about this type of thing boxing you into a corner seem to be well founded. Like Rails, you can move fast if you stay on the happy path, but once you venture off that sacred sidewalk and try to do something weird (i.e., pretty much anything), you’ll find out you can’t. You’re stuck on that sidewalk forever.

Yarn

I prefer Yarn so let’s make sure it’s installed.

brew install yarn

Generate a new Phoenix 1.4 app

This assumes you have both Elixir and Phoenix installed already. If not checkout their guides which do a great job walking through the process.

mix phx.new bulma

Be sure NOT to install any dependencies when prompted.

Manually install all dependencies and create the database:

cd bulma && mix deps.get && mix ecto.create && cd assets && yarn add node-sass sass-loader bulma --dev && yarn && node node_modules/webpack/bin/webpack.js --mode development && cd ..

Switching to sass

Change our file extensions to sass and remove default styles:

mv assets/css/app.css assets/css/app.scss && sed -i '' 's/app.css/app.scss/g' assets/js/app.js && rm assets/css/phoenix.css

Open /assets/webpack.config.js and find the place that tests for css files, it should look like this:

{
  test: /\.css$/,
  use: [MiniCssExtractPlugin.loader, 'css-loader']
}

Now replace it with this:

{
  test: /\.s?css$/,
  use: [MiniCssExtractPlugin.loader, 'css-loader', 'sass-loader']
}

Open /assets/css/app.scss and replace it with the following (mostly copied from the Bulma docs):

@charset "utf-8";

// Import a Google Font
@import url('https://fonts.googleapis.com/css?family=Nunito:400,700');

// Set your brand colors
$purple: #8A4D76;
$pink: #FA7C91;
$brown: #757763;
$beige-light: #D0D1CD;
$beige-lighter: #EFF0EB;

// Update Bulma's global variables
$family-sans-serif: "Nunito", sans-serif;
$grey-dark: $brown;
$grey-light: $beige-light;
$primary: $purple;
$link: $pink;
$widescreen-enabled: false;
$fullhd-enabled: false;

// Update some of Bulma's component variables
$body-background-color: $beige-lighter;
$control-border-width: 2px;
$input-border-color: transparent;
$input-shadow: none;

//Import Bulma
@import 'bulma';

Open /lib/bulma_web/templates/page/index.html.eex and replace it with the following (again mostly copied from Bulma docs):

<section class="section">
  <h1 class="title">
    Bulma
  </h1>

  <p class="subtitle">
    Modern CSS framework based on <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox">Flexbox</a>
  </p>

  <div class="field">
    <div class="control">
      <input class="input" type="text" placeholder="Input">
    </div>
  </div>

  <div class="field">
    <p class="control">
      <span class="select">
        <select>
          <option>Select dropdown</option>
        </select>
      </span>
    </p>
  </div>

  <div class="buttons">
    <a class="button is-primary">Primary</a>
    <a class="button is-link">Link</a>
  </div>
</section>

Test it out

mix phx.server

Code formatting

When you have a snippet of code you’d like to share via Campfire or Ping you can have Basecamp format it for you using the following command:

/code <lang> | [paste]

where <lang> is some programming language.

For example, imagine I have this snippet of ruby code on my clipboard:

def sum_eq_n?(arr, n)
  return true if arr.empty? && n == 0
  arr.product(arr).reject { |a,b| a == b }.any? { |a,b| a + b == n }
end

Type /code ruby | then ⌘ + v to paste and ⏎ to send the message.

Basecamp will output the following nicely formatted code:

Playing Sounds

Dating all the way back to the original version of Campfire there has been a “hidden” ability to play various sound bites. These have been updated over the years and recently include sounds from Game of Thrones, Frozen, and more.

To play a sound just type /play <sound> where <sound> is one of the available sounds. For example, to play the 🎉 Tada sound type /play tada and enjoy!

Help

Both of these useful commands are hidden and remembering all the sounds can be a pain. To help with this they’ve included a help command.

Type /help and Basecamp will spit out documentation along with a list of all the available sounds:

Sometimes you just want to collect some data from a user but have no plans of persisting it to the database. You can use embedded_schema to accomplish this. You’ll get to mostly work with Phoenix/Ecto as usual except without the migration, tables, and saving.

In this post we’ll be creating a Phoenix 1.4 app with a contact form.

Create the Phoenix 1.4 app

The following command will

• create a new Phoenix app called Contact
• install its dependencies
• create the database
• open your browser to http://localhost:4000
• start the webserver

A couple things to note:

1. You will told the directory already exists and asked if you want to continue: Type y and press Enter
2. You will be asked if you want to “Fetch and install dependencies?”: Type y and press Enter
3. The browser will likely tell you the page isn’t found since it tried to load the site before the webserver finished starting. Simply wait a second or two and then reload the page.

mkdir contact ; cd contact ; mix phx.new . --app contact ; mix ecto.create ; open http://localhost:4000 ; mix phx.server

You should be greeted with the Phoenix welcome screen.

Create the Ecto.Schema

Create a new file \lib\contact\message.ex with the following contents:

defmodule Contact.Message do
  use Ecto.Schema
  import Ecto.Changeset

  embedded_schema do
    field :name
    field :email
  end

  def changeset(message, attrs) do
    message
    |> cast(attrs, [:name, :email])
    |> validate_required([:name, :email])
  end
end

Notice we used embedded_schema here. This let’s Ecto know that we don’t plan on saving this schema to the database.

Creating the form

Open \lib\contact_web\templates\page\index.html.eex and replace with the following:

<div class="section">
   <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
  <%= form_for @changeset, Routes.page_path(@conn, :contact), [method: "post"], fn f -> %>
  <%= if @changeset.action do %>
  <div class="alert alert-danger">
      <p>Oops, you might have missed a field! Please check the errors below.</p>
  </div>
  <% end %>
  <div class="field">
      <%= label f, :name %>
      <div class="control">
          <%= text_input f, :name, [class: "input is-large", placeholder: "Your name"] %>
          <%= error_tag f, :name %>
      </div>
  </div>
  <div class="field">
      <%= label f, :email, class: "label is-large" %>
      <div class="control">
          <%= text_input f, :email, [class: "input is-large", type: "email", placeholder: "Your email"] %>
          <%= error_tag f, :email %>
      </div>
  </div>
  <div class="control">
      <%= submit "Send",  class: "button is-primary is-large" %>
  </div>
  <% end %>     
</div>          

Hooking up the controller

Open lib\contact_web\controllers\page_controller.ex and replace with the following:

defmodule ContactWeb.PageController do
  use ContactWeb, :controller
  alias Contact.Message

  def index(conn, _params) do
    changeset = Message.changeset(%Message{}, %{})
    render(conn, "index.html", changeset: changeset)
  end

  def contact(conn, %{"message" => message_params}) do
    changeset =
      %Message{}
      |> Message.changeset(message_params)

    if changeset.valid? do
      # Do something with message_params

      conn
      |> put_flash(:info, "Message sent!")
      |> redirect(to: Routes.page_path(conn, :index))
    else
      changeset = %{changeset | action: :index}
      render(conn, "index.html", changeset: changeset)
    end
  end
end

Here’s an outline of what we’ll cover in this post:

• creating a new Rails 5.2 app using Webpacker and Stimulus
• installing Bulma, my preference over Bootstrap
• installing Font Awesome 5, for icons
• creating a basic site layout with navigation
• wiring up the burger menu with stimulus

Create the Rails app

Yarn

Yarn claims to be “Fast, reliable, and secure dependency management” and it really is.

brew install yarn

Webpacker

This is Rail’s gateway to the land of JavaScript apps and npm packages. Webpacker can live side-by-side with the asset pipeline, although once you fully embrace it, you’ll find little need for the asset pipeline. You can use webpacker to manage all your assets.

Stimulus

A JavaScript framework from Basecamp that integrates nicely with Turbolinks. We’ll use this to “sprinkle” in some behavior to our views.

Rails new

rails new myapp --webpack=stimulus
cd myapp

An initial controller

bin/rails generate controller Home index about

A default route

Change your config/routes.rb file to look like this:

Rails.application.routes.draw do
  get 'home/index'
  get 'home/about'
  root to: 'home#index'
end

Switching from the Asset Pipeline

Open app/views/layouts/application.html.erb and replace stylesheet_link_tag with stylesheet_pack_tag. Next replace javascript_include_tag with javascript_pack_tag.

Bulma

Bulma is a relatively new CSS framework. It feels like a light, streamlined alternative to Bootstrap. Bulma doesn’t include any JavaScript at all. This means some stuff just won’t work out of the box. For example, the burger menu won’t toggle without a little JavaScript help. We’ll get to that later.

yarn add bulma

Open app/javascript/packs/application.js and add the following to the top:

import '../styles'

Create app/javascript/styles.scss:

@import '~bulma/bulma';

Font Awesome 5

To use icons in Bulma you need to include Font Awesome.

yarn add @fortawesome/fontawesome
yarn add @fortawesome/fontawesome-free-regular
yarn add @fortawesome/fontawesome-free-brands

The View

The navbar

Open app/views/layouts/application.html.erb and add the following just above the yield line:

<%= render 'layouts/navbar' %>

Create app/views/layouts/_navbar.html.erb:

<div class="container">
  <nav class="navbar">
    <div class="navbar-brand">
      <a class="navbar-item" href="#">
        <img src="https://bulma.io/images/bulma-logo.png" width="112" height="28">
      </a>
      <div class="navbar-burger burger" data-target="main-nav">
        <span></span>
        <span></span>
        <span></span>
      </div>
    </div>

    <div id="main-nav" class="navbar-menu">
      <div class="navbar-start">
        <%= link_to root_url, class: 'navbar-item' do %>
          <span class="icon">
            <i class="far fa-gem"></i>
          </span>
          <span>Home</span>
        <% end %>
        <%= link_to home_about_url, class: 'navbar-item' do %>
          <span class="icon">
            <i class="far fa-star"></i>
          </span>
          <span>About</span>
        <% end %>
      </div>
    </div>
  </nav>  
</div>

This is basically copied from the Bulma examples. It is a basic nav bar with two menu items; Home and About.

We now have all the pieces in place and can start wiring up our Stimulus controllers.

Create a Stimulus controller

To keep this example simple, we’re going to create a single controller which we’ll attach to the body tag in the main layout. This controller will be responsible for rendering the Font Awesome icons (as described in a previous post) as well as handling our Bulma burger menu.

Create app/javascript/Controllers/main_controller.js:

import fontawesome from '@fortawesome/fontawesome'
import icons from '@fortawesome/fontawesome-free-regular'
import { Controller } from 'stimulus'
export default class extends Controller {
  initialize() {
    fontawesome.library.add(icons)
  }
  connect() {
    fontawesome.dom.i2svg()

    // Get all "navbar-burger" elements
    var $navbarBurgers = Array.prototype.slice.call(document.querySelectorAll('.navbar-burger'), 0);

    // Check if there are any navbar burgers
    if ($navbarBurgers.length > 0) {

      // Add a click event on each of them
      $navbarBurgers.forEach(function ($el) {
        $el.addEventListener('click', function () {

          // Get the target from the "data-target" attribute
          var target = $el.dataset.target;
          var $target = document.getElementById(target);

          // Toggle the class on both the "navbar-burger" and the "navbar-menu"
          $el.classList.toggle('is-active');
          $target.classList.toggle('is-active');

        });
      });
    }
  }
}

This controller imports the icons from Font Awesome when initialize is called. Everytime connect is called it renders the icons and then searches for navbar burgers to attach the appropriate click events on.

Connect the controller

Now we want to connect the body tag to our controller using an HTML5 data attribute.

Open app/views/layouts/application.html.erb and add the following attribute to the <body> tag.

<body data-controller="main">

Testing

Run your rails app and you should see the simple site with a navbar across the top:

Now try shrinking the window until the menus are hidden and replaced with the burger menu. Notice when you click it, the menus reappear:

You now have a Rails 5 app with Turbolinks, Stimulus, and Font Awesome 5. 🥑🍞

The Rails app

rails new myapp --webpack=stimulus

Setting up Font Awesome 5

One of the great things about using FA5 via JS is the ability to only import the icons you’ll actually be using. In this case I only needed the twitter icon.

yarn add @fortawesome/fontawesome
yarn add @fortawesome/fontawesome-free-brands

Create a Stimulus controller

We’re going to create a controller which we’ll attach the body tag in the main layout. This controller will be responsible for importing the needed icons and for telling Font Awesome when they need to be rendered.

Create app/Javascript/Controllers/fa_controller.js

import fontawesome from '@fortawesome/fontawesome'
import faTwitter from '@fortawesome/fontawesome-free-brands/faTwitter'

import { Controller } from 'stimulus'
export default class extends Controller {
  initialize() {
    fontawesome.library.add(faTwitter)
  }
  connect() {
    fontawesome.dom.i2svg()
  }
}

Connect the controller

Now we want to connect the body tag to our controller using an HTML5 data attribute (i.e., <body data-controller='fa'>) like so:

app/views/layouts/application.html.haml

%body{ data: {controller: 'fa' }}

I’m a big fan of Haml so this is my layout but yours may be application.html.erb.

Done

You now have a Rails 5 app with Turbolinks, Stimulus, and Font Awesome 5. 🥑🍞

Setting up Font Awesome 5

These instructions are current as of v5.0.6. Check https://fontawesome.com/get-started for the latest instructions.

In your application.html.erb inside the <head> tag include a link to Font Awesome from their free CDN.

<head>
    ...
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
    <script defer src="https://use.fontawesome.com/releases/v5.0.6/js/all.js"></script>
</head>

Create an init script

We’re going to create a small script to call into Font Awesome’s API and force it to re-render the icons everytime the turbolinks:load event fires.

Create a new file called fontawesome-init.coffee in app/assets/javascripts/ with the following:

$(document).on "turbolinks:load", ->
  FontAwesome.dom.i2svg()

Important!

If your application.js doesn’t have //= require_tree . then you’ll need to add //= require fontawesome-init.

Prevent layout shifting

While optional, this next step will prevent your layout from constantly resizing as the intial view is loaded and the icons are being rendered. Font Awesome 5 adds the fontawesome-i2svg-pending class to the <html> tag while it’s rendering icons. Using a variant of the instructions here, we can take advantage of this and hide the <body> tag until the icons are rendered and that class is removed.

Add the following to your application.scss:

.fontawesome-i2svg-pending body {
	display: none;
}

You now have Rails 5 with Turbolinks working with Font Awesome 5’s SVG with JS approach. 🍰

Install

$ brew install tmux

Using Windows? See here.

The Basics

Start it up

$ tmux

The leader

To use any of the commands you have to type the leader prefix followed by your specific command. The default is CTRL + B. To save space I’ll show the prefix as PX.

Creating windows

PX + c

tmux starts with a window created by default but we can open multiple within the same session. The windows are numbers starting at zero.

Switching windows

PX + 0

The above would switch to window zero. At the bottom in the status bar you’ll see each window listed. The active window is indicated with an asterisk.

Creating panes

PX + % Vertical split
PX + "" Horizontal split

Windows a kind of useless to me. I much prefer to just split a single window into multiple panes and keep everything in sight.

Switching panes

PX + ;

This will cycle from one pane to the next within the same window. Instead of ; you can also use the arrow keys.

Resizing panes

Resizing is so awkward I usually go into command mode for this.

PX + :

: resize-windows -L

L indicates the direction: left. You can also specify U, D, and R for the other four directions. Repeat this command as needed.

Detach

PX + d

This will detach the session, close tmux, but leave your session running in the background.

Customize

vim copy and paste

You can get lost for weeks configuring this stuff but here is a basic setup that’ll let you copy and paste like you do in vim. The config is here: ~/.tmux.conf

set-window-option -g mode-keys vi
bind-key -t vi-copy 'v' begin-selection
bind-key -t vi-copy 'y' copy-selection

Disable the mouse

The prevent accidental scrolling and trashing your tmux session I recommend you immediately disable the mouse.

PX + :

: setw -g mode-mouse off

Advanced

I haven’t really even scratch the surface. After you’ve been using tmux for a while you’ll want to customze your status bar and start messing with powerlines glyphs. To learn how to do that and get a cooler setup I recommend you read tmux 2 Productive Mouse-Free Development.