TL;DR

For typing, I personally prefer Hall Effect keyboards by a huge margin.
I know most people hype them mainly for gaming, but for me the typing experience itself feels far better.
The keyboards I used: Skyloong GK75 HE (Magnetic) and Redragon Kumara K552 (Mechanical).

Why I prefer Hall Effect for typing

After getting used to a Hall Effect keyboard, going back to a normal mechanical keyboard feels old and less responsive.

The biggest reason is the low actuation distance and lower force required.
I use around 0.6mm actuation, so keys register with very little movement and effort.

On many mechanical keyboards, I feel like:

• I have to press deeper
• Apply more force
• Move my fingers more overall

That extra travel adds up during long typing sessions.

With HE keyboards:

• typing feels lighter
• fingers get less tired
• inputs feel more instant
• overall typing feels smoother

Comfort & typing speed

The reduced travel distance genuinely made typing more comfortable for me.

On my old mechanical keyboard I averaged around 80–90 WPM.
On my Hall Effect keyboard I usually get around 90–105 WPM consistently.

Not saying HE magically increases everyone’s speed, but for me the comfort and responsiveness definitely helped.

Sound

I still think mechanical keyboards generally sound better, especially if you like thocky/clicky builds.

But Hall Effect keyboards are not bad sounding at all.
If you like smoother and quieter sound profiles, you may actually prefer them.
I got spotify to please my ears, just kidding.

Features & durability

Another thing I like is the feature set:

• adjustable actuation
• rapid trigger
• customizable response
• analog-style control on some boards

Mechanical keyboards mostly win in switch variety and sound customization.

As for durability, people say HE keyboards should last longer in theory since there’s less physical contact involved.
Realistically though, only long-term use will tell.

My old mechanical keyboard lasted about 3.5-4 years before some keys started behaving inconsistently.

I’m still a student and definitely still learning, but the setup somehow evolved into something surprisingly robust and genuinely comfortable to use daily. Tell me if I should be something else.

I still wanted:

* standard `hjkl` and others.

* normal plugin compatibility

* macros/tutorials/docs to work normally

* zero remapping headaches

TL;DR:

I built a small Neovim + Hyprland setup that dynamically switches my *system keyboard layout* based on Vim mode:

* Normal/Visual → QWERTY

* Insert/Terminal typing → Programmer Dvorak

while automatically restoring my previous desktop layout on focus changes and exit.

…but I *also* didn’t want to mentally switch back to QWERTY every time I typed actual text.

So I ended up building a small Neovim + Hyprland keyboard-layout state manager that dynamically switches the *system* keyboard layout based on editor mode.

So I get:

* standard Vim motions (`hjkl` untouched)

* full plugin compatibility

* ergonomic typing in insert mode

* zero Vim remapping

Current behavior:

* Normal mode → QWERTY

* Visual mode → QWERTY

* Insert mode → Programmer Dvorak

* Terminal typing → Programmer Dvorak

And additionally:

* when Neovim loses focus → restore previous desktop layout

* when focus returns → restore the correct modal layout

* when Neovim exits → restore the original layout again

So Neovim basically behaves like an isolated modal keyboard-layout environment.

Important part:

I’m **not remapping Vim at all**.

`hjkl`, text objects, operators, plugins, macros, everything stays completely standard.

The layout switching happens at the OS level using:

* Hyprland

* Wayland

* Lua autocmds

* `hyprctl switchxkblayout`

* `hyprctl devices -j`

I originally started with some extremely cursed grep/sed shell hacks, but eventually cleaned it up into proper JSON parsing and focus-aware state management.

A few things that made the setup much more reliable:

* using `ModeChanged` instead of only `InsertEnter/Leave`

* tracking focus ownership

* restoring the exact previous external layout

* preventing redundant layout switches

* startup synchronization

* handling terminal-mode separately

Tiny example:

```lua

local function apply_layout_for_current_mode()

local mode = vim.api.nvim_get_mode().mode

if mode:match("i") or mode:match("t") then

switch_layout(DVORAK)

else

switch_layout(QWERTY)

end

end

```

Honestly most of this started as vibe-coded experimentation while I was learning Lua/Nvim internals. I’m still a student and definitely still learning, but the setup somehow evolved into something surprisingly robust and genuinely comfortable to use daily.

What I like most is that it avoids the usual tradeoff of:

> “either remap Vim or suffer typing ergonomics forever”

This approach preserves canonical Vim behavior *and* keeps Dvorak where typing actually matters.

Curious if anyone else here has tried something similar with:

* Dvorak

* Colemak

* QMK layers

* Kanata/KMonad

* modal layout switching

* ergonomic keyboard workflows

Would love feedback/ideas from people deeper into alternate layouts or Neovim internals because this accidentally became a way more interesting little systems project than I expected.